Attachment #178373 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.id.CDOIDAndVersion;
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.Collection;
import java.util.HashSet;
import java.util.Set;

/**
 * @author Caspar De Groot
 * @since 4.0
 */
public class CommitIntegrityCheck
{
  /**
   * 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
  }

  private InternalCDOTransaction tx;

  private Set<CDOID> newIDs, dirtyIDs, detachedIDs;

  private Style style;

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

  private StringBuilder exceptionMessage = new StringBuilder();

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

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

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

  private Set<CDOID> collectIDs(Collection<? extends CDOIDAndVersion> cdoIDandVersions)
  {
    Set<CDOID> cdoIDs = new HashSet<CDOID>();
    for (CDOIDAndVersion idAndV : cdoIDandVersions)
    {
      cdoIDs.add(idAndV.getID());
    }
    return cdoIDs;
  }

  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 = tx.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 = tx.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 = tx.getObject(dirtyID);
      analyzeRevisionDelta((InternalCDOObject)dirtyObject);
    }

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

  private CDOID getContainerOrResourceID(InternalCDORevision revision)
  {
    CDOID containerOrResourceID = null;
    Object idOrObject = revision.getContainerID();
    if (idOrObject != null)
    {
      containerOrResourceID = (CDOID)tx.convertObjectToID(idOrObject);
    }
    if (containerOrResourceID == null || containerOrResourceID.getType() == Type.NULL)
    {
      idOrObject = revision.getResourceID();
      if (idOrObject != null)
      {
        containerOrResourceID = (CDOID)tx.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 = tx.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 fDelta : rDelta.getFeatureDeltas())
    {
      EStructuralFeature feat = fDelta.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 (fDelta instanceof CDOListFeatureDelta)
          {
            for (CDOFeatureDelta innerFeatDelta : ((CDOListFeatureDelta)fDelta).getListChanges())
            {
              checkContainmentDelta(innerFeatDelta, dirtyObject);
            }
          }
          else
          {
            checkContainmentDelta(fDelta, dirtyObject);
          }
        }
      }
    }
  }

  private void checkContainmentDelta(CDOFeatureDelta fDelta, CDOObject dirtyObject) throws CommitIntegrityException
  {
    if (fDelta instanceof CDORemoveFeatureDelta)
    {
      Object idOrObject = ((CDORemoveFeatureDelta)fDelta).getValue();
      CDOID id = (CDOID)tx.convertObjectToID(idOrObject);
      checkIncluded(id, "removed child of", dirtyObject);
    }
    else if (fDelta instanceof CDOAddFeatureDelta)
    {
      Object idOrObject = ((CDOAddFeatureDelta)fDelta).getValue();
      CDOID id = (CDOID)tx.convertObjectToID(idOrObject);
      if (id.getType() != CDOID.Type.NULL)
      {
        checkIncluded(id, "added child of", dirtyObject);
      }
    }
    else if (fDelta instanceof CDOSetFeatureDelta)
    {
      Object newIdOrObject = ((CDOSetFeatureDelta)fDelta).getValue();
      Object oldIdOrObject = ((CDOSetFeatureDelta)fDelta).getOldValue();
      CDOID oldId = (CDOID)tx.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)tx.convertObjectToID(newIdOrObject);
          checkIncluded(newId, "new child of", dirtyObject);
        }
      }
      else
      {
        // New child, no old child
        CDOID newId = (CDOID)tx.convertObjectToID(newIdOrObject);
        checkIncluded(newId, "new child of", dirtyObject);
      }
    }
    else if (fDelta instanceof CDOClearFeatureDelta)
    {
      EStructuralFeature feat = ((CDOClearFeatureDelta)fDelta).getFeature();
      InternalCDORevision cleanRev = tx.getCleanRevisions().get(dirtyObject);
      int n = cleanRev.size(feat);
      for (int i = 0; i < n; i++)
      {
        Object idOrObject = cleanRev.get(feat, i);
        CDOID id = (CDOID)tx.convertObjectToID(idOrObject);
        checkIncluded(id, "removed child of", dirtyObject);
      }
    }
    else if (fDelta instanceof CDOUnsetFeatureDelta)
    {
      EStructuralFeature feat = ((CDOUnsetFeatureDelta)fDelta).getFeature();
      InternalCDORevision cleanRev = tx.getCleanRevisions().get(dirtyObject);
      Object idOrObject = cleanRev.getValue(feat);
      CDOID id = (CDOID)tx.convertObjectToID(idOrObject);
      checkIncluded(id, "removed child of", dirtyObject);
    }
    else
    {
      throw new RuntimeException("Unexpected delta type: " + fDelta.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 = tx.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 = tx.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 = tx.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);
  }

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




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

Lines 199-202 Link Here

(-)src/org/eclipse/emf/internal/cdo/transaction/CDOXACommitContextImpl.java (+5 lines)
199	{	199	{
200	return MessageFormat.format("CDOXACommitContext[{0}, {1}]", transactionManager, state);	200	return MessageFormat.format("CDOXACommitContext[{0}, {1}]", transactionManager, state);
201	}	201	}
		202
		203	public boolean isPartialCommit()
		204	{
		205	return delegateCommitContext.isPartialCommit();
		206	}
202	}	207	}




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 RuntimeException("Not yet implemented");
  }

  public Set<EObject> getCommittables()
  {
    throw new RuntimeException("Not yet implemented");
  }

  /**
   * @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 / +30 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	return super.toStringAdditional() + MessageFormat.format(", oldValue={0}", oldValueForMessage); //$NON-NLS-1$
		90	}
62	}	91	}

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

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 RuntimeException("Not yet implemented");
		442	}
		443
		444	public Set<EObject> getCommittables()
		445	{
		446	throw new RuntimeException("Not yet implemented");
		447	}
		448
438	/**	449	/**
439	* @author Simon McDuff	450	* @author Simon McDuff
440	*/	451	*/