Attachment #115764 for bug #251544

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

Lines 22-27 Link Here

(-)src/org/eclipse/emf/cdo/tests/AllTestsAllConfigs.java (+2 lines)
22	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_250757_Test;	22	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_250757_Test;
23	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_251087_Test;	23	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_251087_Test;
24	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_251263_Test;	24	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_251263_Test;
		25	import org.eclipse.emf.cdo.tests.bugzilla.Bugzilla_251544_Test;
25	import org.eclipse.emf.cdo.tests.config.ConfigTest;	26	import org.eclipse.emf.cdo.tests.config.ConfigTest;
26	import org.eclipse.emf.cdo.tests.config.ConfigTestSuite;	27	import org.eclipse.emf.cdo.tests.config.ConfigTestSuite;
27		28
Lines 89-94 Link Here
89	testClasses.add(Bugzilla_250757_Test.class);	90	testClasses.add(Bugzilla_250757_Test.class);
90	testClasses.add(Bugzilla_251087_Test.class);	91	testClasses.add(Bugzilla_251087_Test.class);
91	testClasses.add(Bugzilla_251263_Test.class);	92	testClasses.add(Bugzilla_251263_Test.class);
		93	testClasses.add(Bugzilla_251544_Test.class);
92		94
93	// TODO testClasses.add(NonCDOResourceTest.class);	95	// TODO testClasses.add(NonCDOResourceTest.class);
94	// TODO testClasses.add(GeneratedEcoreTest.class);	96	// TODO testClasses.add(GeneratedEcoreTest.class);

Lines 63-69 Link Here

(-)src/org/eclipse/emf/cdo/tests/TransactionTest.java (-2 lines)
63	}	63	}
64	}	64	}
65		65
66	@SuppressWarnings("deprecation")
67	public void testCreateManyTransactions() throws Exception	66	public void testCreateManyTransactions() throws Exception
68	{	67	{
69	msg("Opening session");	68	msg("Opening session");
Lines 79-85 Link Here
79	msg("Transaction " + i + " (" + lastDuration + ")");	78	msg("Transaction " + i + " (" + lastDuration + ")");
80	lastDuration = System.currentTimeMillis();	79	lastDuration = System.currentTimeMillis();
81	transaction = session.openTransaction();	80	transaction = session.openTransaction();
82	transaction.setUniqueResourceContents(false);
83	resource = transaction.getResource("/test2");	81	resource = transaction.getResource("/test2");
84	Category category = getModel1Factory().createCategory();	82	Category category = getModel1Factory().createCategory();
85	resource.getContents().add(category);	83	resource.getContents().add(category);

Lines 24-30 Link Here

(-)src/org/eclipse/emf/cdo/tests/bugzilla/Bugzilla_246456_Test.java (-2 lines)
24	*/	24	*/
25	public class Bugzilla_246456_Test extends AbstractCDOTest	25	public class Bugzilla_246456_Test extends AbstractCDOTest
26	{	26	{
27	@SuppressWarnings("deprecation")
28	public void testBugzilla_246456() throws Exception	27	public void testBugzilla_246456() throws Exception
29	{	28	{
30	msg("Opening session");	29	msg("Opening session");
Lines 36-42 Link Here
36	.setCapacityRevised(10);	35	.setCapacityRevised(10);
37	((LRURevisionCache)((TwoLevelRevisionCache)transaction.getSession().getRevisionManager().getCache()).getLevel1())	36	((LRURevisionCache)((TwoLevelRevisionCache)transaction.getSession().getRevisionManager().getCache()).getLevel1())
38	.setCapacityCurrent(10);	37	.setCapacityCurrent(10);
39	transaction.setUniqueResourceContents(false);
40		38
41	msg("Creating resource");	39	msg("Creating resource");
42	CDOResource resource = transaction.createResource("/test1");	40	CDOResource resource = transaction.createResource("/test1");




package org.eclipse.emf.cdo.tests.bugzilla;

import org.eclipse.emf.cdo.CDOSession;
import org.eclipse.emf.cdo.CDOTransaction;
import org.eclipse.emf.cdo.eresource.CDOResource;
import org.eclipse.emf.cdo.tests.AbstractCDOTest;
import org.eclipse.emf.cdo.tests.model1.Order;
import org.eclipse.emf.cdo.tests.model1.OrderDetail;

import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EObject;

/**
 * Resources fetched using CDOViewImpl.getResource(CDOID) not added to ResourceSet
 * <p>
 * See https://bugs.eclipse.org/251544
 * 
 * @author Simon McDuff
 */
public class Bugzilla_251544_Test extends AbstractCDOTest
{
  public void testFromPersistedToTransient() throws Exception
  {
    CDOSession session = openModel1Session();
    CDOTransaction transaction = session.openTransaction();
    CDOResource resource = transaction.createResource("/my/resource");

    Order order1 = getModel1Factory().createOrder();
    OrderDetail orderDetail = getModel1Factory().createOrderDetail();
    EList<EObject> contentList = resource.getContents();
    resource.getContents().add(order1);
    order1.getOrderDetails().add(orderDetail);
    EList<OrderDetail> list = order1.getOrderDetails();
    resource.getContents().remove(0); // remove object by index
    list.remove(orderDetail);

    transaction.commit();

    resource.delete(null);

    assertSame(contentList, resource.getContents());
  }

  public void testFromTransientToPersisted() throws Exception
  {
    CDOSession session = openModel1Session();
    CDOTransaction transaction = session.openTransaction();
    CDOResource resource = transaction.createResource("/my/resource");

    Order order1 = getModel1Factory().createOrder();
    OrderDetail orderDetail = getModel1Factory().createOrderDetail();
    EList<OrderDetail> orderDetails = order1.getOrderDetails();
    order1.getOrderDetails().add(orderDetail);

    msg("Persist the graph");
    resource.getContents().add(order1);
    assertSame(orderDetails, order1.getOrderDetails());
    resource.getContents().remove(0); // remove object by index
    assertSame(orderDetails, order1.getOrderDetails());
    assertEquals(true, orderDetails.remove(orderDetail));
    transaction.commit();
  }

}




import org.eclipse.emf.ecore.resource.impl.ExtensibleURIConverterImpl;
import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
import org.eclipse.emf.ecore.util.InternalEList;
import org.eclipse.emf.ecore.util.NotifyingInternalEListImpl;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;


  @SuppressWarnings("unchecked")
  public EList<EObject> getContents()
  {
    /*
     * if (FSMUtil.isTransient(this)) { EList<EObject> transientContents =
     * (EList<EObject>)eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS]; if (transientContents == null) {
     * transientContents = new TransientContents<EObject>(); eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS] =
     * transientContents; // throw new ImplementationError(); } return transientContents; }
     */
        eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS] = transientContents;
        // throw new ImplementationError();
      }

      return transientContents;
    }

    return (EList<EObject>)eGet(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS, true);
  }

  {
    if (eStructuralFeature == EresourcePackage.eINSTANCE.getCDOResource_Contents())
    {
      return new CDOContentEList(eStructuralFeature);
    }

    return super.createList(eStructuralFeature);

   * 
   * @ADDED
   * @author Eike Stepper
   * @since 2.0
   */
  protected class CDOContentEList extends BasicEStoreEList<Object>
  {
    private static final long serialVersionUID = 1L;

    public CDOContentEList(EStructuralFeature eStructuralFeature)
    public PersistentContents(EStructuralFeature eStructuralFeature)
    {
      super(CDOResourceImpl.this, eStructuralFeature);
      if (!cdoView().hasUniqueResourceContents())
      {
        kind &= ~IS_UNIQUE;
      }
    }

    /**

    @Override
    public NotificationChain inverseAdd(Object object, NotificationChain notifications)
    {
      if (FSMUtil.isTransient(CDOResourceImpl.this))
      InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
      notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications);
      // Attach here instead of i CDOObjectImpl.eSetResource because EMF does it also here
      if (FSMUtil.isTransient(cdoObject))
      {
        InternalEObject eObject = (InternalEObject)object;
        notifications = eObject.eSetResource(CDOResourceImpl.this, notifications);
      }
      else
      {
        CDOTransactionImpl transaction = cdoView().toTransaction();
        InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
        notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications);
        // Attach here instead of i CDOObjectImpl.eSetResource because EMF does it also here
        if (FSMUtil.isTransient(cdoObject))
        {
          attached(cdoObject, transaction);
        }
      }

      return notifications;
    }


    @Override
    public NotificationChain inverseRemove(Object object, NotificationChain notifications)
    {
      if (FSMUtil.isTransient(CDOResourceImpl.this))
      detached(eObject);
      return eObject.eSetResource(null, notifications);
    }
  }

  /**
   * TODO Change superclass to NotifyingInternalEListImpl when EMF 2.3 is out of maintenance
   * <p>
   * TODO Reuse {@link ResourceImpl.ContentsEList}!!! --> Bugzilla!
   * 
   * @ADDED
   * @author Eike Stepper
   */
  protected class TransientContents<E extends Object & EObject> extends NotifyingInternalEListImpl<E>
  {
    private static final long serialVersionUID = 1L;

    public TransientContents()
    {
    }

    public TransientContents(Collection<? extends E> collection)
    {
      super(collection);
    }

    public TransientContents(int initialCapacity)
    {
      super(initialCapacity);
    }

    /**
     * Optimization taken from ResourceImpl.EContentList.contains
     * 
     * @since 2.0
     */
    @Override
    public boolean contains(Object object)
    {
      return size <= 4 ? super.contains(object) : object instanceof InternalEObject
          && ((InternalEObject)object).eDirectResource() == CDOResourceImpl.this;
    }

    @Override
    public Object getNotifier()
    {
      return CDOResourceImpl.this;
    }

    @Override
    public int getFeatureID()
    {
      return EresourcePackage.CDO_RESOURCE__CONTENTS;
    }

    @Override
    protected boolean isNotificationRequired()
    {
      return eNotificationRequired();
    }

    @Override
    protected boolean useEquals()
    {
      return false;
    }

    @Override
    protected boolean hasInverse()
    {
      return true;
    }

    @Override
    protected boolean isUnique()
    {
      return true;
    }

    /**
     * @since 2.0
     */
    /*
     * IMPORTANT: Compile errors in this method might indicate an old version of EMF. Legacy support is only enabled for
     * EMF with fixed bug #247130. These compile errors do not affect native models!
     */
    public InternalEList<E> readWriteFiringList()
    {
      return this;
    }

    @Override
    public NotificationChain inverseAdd(E object, NotificationChain notifications)
    {
      InternalEObject eObject = (InternalEObject)object;
      notifications = eObject.eSetResource(CDOResourceImpl.this, notifications);
      // CDOResourceImpl.this.attached(eObject);
      return notifications;
    }

    @Override
    public NotificationChain inverseRemove(E object, NotificationChain notifications)
    {
      InternalEObject eObject = (InternalEObject)object;
      // CDOResourceImpl.this.detached(eObject);
      return eObject.eSetResource(null, notifications);
    }

    @Override
    protected void didAdd(int index, E object)
    {
      super.didAdd(index, object);
      modified();
    }

    @Override
    protected void didRemove(int index, E object)
    {
      super.didRemove(index, object);
      modified();
    }

    @Override
    protected void didSet(int index, E newObject, E oldObject)
    {
      super.didSet(index, newObject, oldObject);
      modified();
    }

    @Override
    protected void didClear(int oldSize, Object[] oldData)
    {
      if (oldSize == 0)
      {
        InternalEObject eObject = (InternalEObject)object;
        notifications = eObject.eSetResource(null, notifications);
      }
      else
      {
        InternalEObject eObject = (InternalEObject)object;
        detached(eObject);
        notifications = eObject.eSetResource(null, notifications);
      }
      return notifications;
    }

    /**

      }
    }

    /**
     * @since 2.0
     */
    protected void modified()
    {
      if (isTrackingModification())

        setModified(true);
      }
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean useEquals()
    {
      return false;
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean hasInverse()
    {
      return true;
    }

    /**
     * @since 2.0
     */
    @Override
    protected boolean isUnique()
    {
      return true;
    }
  }

} // CDOResourceImpl




  public boolean hasConflict();

  /**
   * @see #setUniqueResourceContents(boolean)
   * @deprecated This performance tweak is not necessary with EMF 2.5 anymore and is likely to be removed when CDO
   *             reaches 2.0. In the meantime it can be safely used.
   */
  @Deprecated
  public boolean hasUniqueResourceContents();

  /**
   * Specifies whether the contents list of resources will be unique or not.
   * <p>
   * This property is transient in that it does not stick with resources outside of the scope of this view. Especially
   * it will not be persisted with resources in the repository. Each new view will start with <code>true</code> as a
   * default value. Changing to <code>false</code> will subsequently apply to all resources being loaded or created.
   * <p>
   * Notice that the resource contents is a containment list and as such <b>must be</b> unique. Setting this property to
   * <code>false</code> is only recommended for performance optimization when uniqueness is granted by other means.
   * Violating the uniqueness constraint will result in unpredictable behaviour and possible corruption of the
   * repository!
   * 
   * @deprecated This performance tweak is not necessary with EMF 2.5 anymore and is likely to be removed when CDO
   *             reaches 2.0. In the meantime it can be safely used.
   */
  @Deprecated
  public void setUniqueResourceContents(boolean uniqueResourceContents);

  /**
   * Returns <code>true</code> if the {@link CDOObject objects} in this view will notify their
   * {@link org.eclipse.emf.common.notify.Adapter adapters} about the fact that they are <em>invalidated</em> (due to
   * remote changes), <code>false</code> otherwise.





  private CDOURIHandler uriHandler = new CDOURIHandler(this);

  private boolean uniqueResourceContents = true;

  private boolean invalidationNotificationEnabled;

  private CDORevisionPrefetchingPolicy revisionPrefetchingPolicy;

    return false;
  }

  @Deprecated
  public boolean hasUniqueResourceContents()
  {
    return uniqueResourceContents;
  }

  @Deprecated
  public void setUniqueResourceContents(boolean uniqueResourceContents)
  {
    this.uniqueResourceContents = uniqueResourceContents;
  }

  /**
   * @since 2.0
   */




import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.NotificationChain;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.BasicEMap;
import org.eclipse.emf.common.util.ECollections;
import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.ecore.impl.EStoreEObjectImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.Resource.Internal;
import org.eclipse.emf.ecore.util.DelegatingEcoreEList;
import org.eclipse.emf.ecore.util.DelegatingFeatureMap;
import org.eclipse.emf.ecore.util.EcoreEList;
import org.eclipse.emf.ecore.util.EcoreEMap;


  private InternalCDORevision revision;

  /**
   * CDO used this list instead of eSettings for transient objects. EMF used eSettings as cache. CDO deactivate the
   * cache but EMF still use eSettings to store list wrapper. CDO needs another place to store the real list with the
   * actual data (transient mode) and accessible through EStore. This allow CDO to always use the same instance of the
   * list wrapper.
   */
  private transient Object eTransientSettings[];

  public CDOObjectImpl()
  {
    state = CDOState.TRANSIENT;
    eContainer = null;
    eTransientSettings = null;
  }

  public CDOID cdoID()

    return revision;
  }

  /**
   * @since 2.0
   */
  protected Object[] eTransientSettings()
  {
    if (eTransientSettings == null)
    {
      int size = eClass().getFeatureCount() - eStaticFeatureCount();
      eTransientSettings = size == 0 ? ENO_SETTINGS : new Object[size];
    }
    return eTransientSettings;
  }

  /**
   * @since 2.0
   */
  protected Object[] eBasicTransientSettings()
  {
    return eTransientSettings;
  }

  public CDOClass cdoClass()
  {
    return getCDOClass(this);


  public void cdoInternalPostLoad()
  {
    // Reset EMAP objects
    if (eSettings != null)
    {
      // Make sure transient feature are kept but persisted value are not cached.

   */
  public void cdoInternalCleanup()
  {

    {
      // Make sure transient feature are kept but persisted value are not cached.
      EClass eClass = eClass();
      for (int i = 0; i < eClass.getFeatureCount(); i++)
      {
        EStructuralFeature eFeature = cdoInternalDynamicFeature(i);
        // We need to keep the existing list if possible.
        if (!eFeature.isTransient())
        {
          eSettings[i] = null;
        }
      }
    }
  }

  public void cdoInternalPostAttach()

      revision.setResourceID(cdoResource.cdoID());
    }

    eSettings();

    EClass eClass = eClass();
    for (int i = 0; i < eClass.getFeatureCount(); i++)
    {

        populateRevisionFeature(view, revision, eFeature, eSettings, i);
      }
    }
    eTransientSettings = null;
  }

  @SuppressWarnings("unchecked")

      TRACER.format("Populating feature {0}", cdoFeature);
    }

    Object setting = eBasicTransientSettings() != null ? eTransientSettings()[i] : null;
    if (setting == null)
    {
      setting = eFeature.getDefaultValue();
    }

    if (cdoFeature.isMany())
    {
      if (setting != null)


      revision.set(cdoFeature, 0, setting);
    }

    if (eSettings != null)
    {
      eSettings[i] = null;
    }
  }

  /**
   * It is really important to access the data to go through getStore. eStore will redirect you to the transient data.
   */
  public void cdoInternalPostDetach()
  {
    if (TRACER.isEnabled())


    CDOViewImpl view = cdoView();
    super.eSetDirectResource(cdoDirectResource());
    eContainer = getStore().getContainer(this);
    eContainerFeatureID = getStore().getContainingFeatureID(this);
    if (eContainer != null && eContainmentFeature().isResolveProxies())
    {

    }

    // Ensure that the internal eSettings array is initialized;
    eTransientSettings = null;
    eTransientSettings();

    EClass eClass = eClass();
    for (int i = 0; i < eClass.getFeatureCount(); i++)

    }
  }

  @SuppressWarnings("unchecked")
  private void depopulateRevisionFeature(CDOViewImpl view, InternalCDORevision revision, EStructuralFeature eFeature,
      Object[] eSettings, int i)
  {

    EStructuralFeature.Internal internalFeature = (EStructuralFeature.Internal)eFeature;
    EReference oppositeReference = cdoID().isTemporary() ? null : internalFeature.getEOpposite();

    CDOStore cdoStore = getStore();
    EStore transientStore = eStore();
    if (eFeature.isMany())
    {

      int size = cdoStore.size(this, eFeature);
      int size = eStore().size(this, eFeature);
      for (int index = 0; index < size; index++)
      {
        // Do not trigger events
        // Do not trigger inverse updates
        Object object = cdoStore.get(this, eFeature, index);
        transientStore.add(this, eFeature, index, object);
        if (oppositeReference != null)
        {
          adjustOppositeReference((InternalEObject)object, oppositeReference);

    }
    else
    {
      Object object = cdoStore.get(this, eFeature, EStore.NO_INDEX);
      transientStore.set(this, eFeature, EStore.NO_INDEX, object);
      if (oppositeReference != null)
      {
        adjustOppositeReference((InternalEObject)object, oppositeReference);
      }
    }
  }

        public EStoreEcoreEMap()
        {
          super((EClass)eType, eType.getInstanceClass(), null);
          delegateEList = new BasicEStoreEList<BasicEMap.Entry<Object, Object>>(CDOObjectImpl.this, eStructuralFeature)
          {
            private static final long serialVersionUID = 1L;



        private void checkListForReading()
        {
          if (!FSMUtil.isTransient(CDOObjectImpl.this))
          {
            CDOStateMachine.INSTANCE.read(CDOObjectImpl.this);
          }
        }

        /**

      return new EStoreEcoreEMap();
    }

    return super.createList(eStructuralFeature);
  }

  @Override

  }

  /**
   * @since 2.0
   */
  @Override
  public InternalEObject.EStore eStore()
  {
    return false;
  }

  @Override
  public Object dynamicGet(int dynamicFeatureID)
  {
    if (FSMUtil.isTransient(this))
    {
      return CDOStoreSettingsImpl.TRANSIENT_STORE;
      {
        return null;
      }

      return eSettings[dynamicFeatureID];
    }

    // Delegate to CDOStore
    return super.dynamicGet(dynamicFeatureID);
  }

  @Override
  public boolean eIsSet(EStructuralFeature feature)
  {
    if (FSMUtil.isTransient(this))
    {
      // TODO What about defaultValues != null?
      if (eSettings == null)
      {
        return false;
      }

      return eSettings[eDynamicFeatureID(feature)] != null;
    }

    // Delegate to CDOStore
    return super.eIsSet(feature);
  }

  @Override
  public void dynamicSet(int dynamicFeatureID, Object value)
  {
    if (FSMUtil.isTransient(this))
    {
      eSettings(); // Important to create eSettings array if necessary
      eSettings[dynamicFeatureID] = value;
    }
    else
    {
      // Delegate to CDOStore
      super.dynamicSet(dynamicFeatureID, value);
    }
    return getStore();
  }

  /**
   * Don't cache non-transient features in this CDOObject's {@link #eSettings()}.
   */
  @Override
  protected boolean eIsCaching()
  {
    return false;
    {
      if (eSettings != null)
      {
        eSettings[dynamicFeatureID] = null;
      }
    }
    else
    {
      // Delegate to CDOStore
      super.dynamicUnset(dynamicFeatureID);
    }
  }

  @Override


  private CDOStore getStore()
  {
    return cdoView().getStore();
  }

  /**
   * @since 2.0
   * 
   * @author Eike Stepper
   */
  public static class CDOStoreSettingsImpl implements InternalEObject.EStore
  {
    protected static CDOStoreSettingsImpl TRANSIENT_STORE = new CDOStoreSettingsImpl();

    protected Object getValue(InternalEObject eObject, int dynamicFeatureID)
    {
      return ((CDOObjectImpl)eObject).eTransientSettings()[dynamicFeatureID];
    }

    @Override
    protected List<E> delegateList()
    {
      throw new UnsupportedOperationException();
    }

    protected EList<Object> getValueAsList(InternalEObject eObject, int dynamicFeatureID)
    public EStructuralFeature getEStructuralFeature()
    {
      @SuppressWarnings("unchecked")
      EList<Object> result = (EList<Object>)getValue(eObject, dynamicFeatureID);
      if (result == null)
      {
        result = new BasicEList<Object>();
        ((CDOObjectImpl)eObject).eTransientSettings()[dynamicFeatureID] = result;
      }
      return result;
    }

    protected Object setValue(InternalEObject eObject, int dynamicFeatureID, Object newValue)
    protected void delegateAdd(int index, Object object)
    {
      Object eSettings[] = ((CDOObjectImpl)eObject).eTransientSettings();
      try
      {
        return eSettings[dynamicFeatureID];
      }
      finally
      {
        eSettings[dynamicFeatureID] = newValue;
      }
    }

    protected int eDynamicFeatureID(InternalEObject eObject, EStructuralFeature feature)
    protected void delegateAdd(Object object)
    {
      return ((CDOObjectImpl)eObject).eDynamicFeatureID(feature);
    }

    public Object get(InternalEObject eObject, EStructuralFeature feature, int index)
    protected List<E> delegateBasicList()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      if (feature.isMany())
      {
        return getValueAsList(eObject, dynamicFeatureID).get(index);
      }
      return getValue(eObject, dynamicFeatureID);
      Object[] data = getStore().toArray(owner, eStructuralFeature);
      return new EcoreEList.UnmodifiableEList<E>(owner, eStructuralFeature, data.length, data);
    }

    public Object set(InternalEObject eObject, EStructuralFeature feature, int index, Object value)
    protected void delegateClear()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      if (feature.isMany())
      {
        return getValueAsList(eObject, dynamicFeatureID).set(index, value);
      }
      return setValue(eObject, dynamicFeatureID, value);
    }

    public void add(InternalEObject eObject, EStructuralFeature feature, int index, Object value)
    protected boolean delegateContains(Object object)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      getValueAsList(eObject, dynamicFeatureID).add(index, value);
    }

    public Object remove(InternalEObject eObject, EStructuralFeature feature, int index)
    protected boolean delegateContainsAll(Collection<?> collection)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).remove(index);
        if (!delegateContains(o))
        {
          return false;
        }
      }
      return true;
    }

    public Object move(InternalEObject eObject, EStructuralFeature feature, int targetIndex, int sourceIndex)
    @Override
    protected E delegateGet(int index)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).move(targetIndex, sourceIndex);
    }

    public void clear(InternalEObject eObject, EStructuralFeature feature)
    protected int delegateHashCode()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      if (feature.isMany())
      {
        getValueAsList(eObject, dynamicFeatureID).clear();
      }
      setValue(eObject, dynamicFeatureID, null);
    }

    public int size(InternalEObject eObject, EStructuralFeature feature)
    protected int delegateIndexOf(Object object)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).size();
    }

    public int indexOf(InternalEObject eObject, EStructuralFeature feature, Object value)
    protected boolean delegateIsEmpty()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).indexOf(value);
    }

    public int lastIndexOf(InternalEObject eObject, EStructuralFeature feature, Object value)
    protected Iterator<E> delegateIterator()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).lastIndexOf(value);
    }

    public Object[] toArray(InternalEObject eObject, EStructuralFeature feature)
    protected int delegateLastIndexOf(Object object)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).toArray();
    }

    public <T> T[] toArray(InternalEObject eObject, EStructuralFeature feature, T[] array)
    protected ListIterator<E> delegateListIterator()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).toArray(array);
    }

    public boolean isEmpty(InternalEObject eObject, EStructuralFeature feature)
    @Override
    protected E delegateRemove(int index)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).isEmpty();
    }

    public boolean contains(InternalEObject eObject, EStructuralFeature feature, Object value)
    @Override
    protected E delegateSet(int index, E object)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).contains(value);
    }

    public int hashCode(InternalEObject eObject, EStructuralFeature feature)
    protected int delegateSize()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValueAsList(eObject, dynamicFeatureID).hashCode();
    }

    public InternalEObject getContainer(InternalEObject eObject)
    protected Object[] delegateToArray()
    {
      return null;
    }

    public EStructuralFeature getContainingFeature(InternalEObject eObject)
    protected <T> T[] delegateToArray(T[] array)
    {
      // This should never be called.
      //
      throw new UnsupportedOperationException();
      // Entry entry = new Entry(eObject, CONTAINING_FEATURE);
      // return (EStructuralFeature)map.get(entry);
    }

    public EObject create(EClass eClass)
    @Override
    protected E delegateMove(int targetIndex, int sourceIndex)
    {
      InternalEObject result = new EStoreEObjectImpl(eClass, this);
      return result;
    }

    public boolean isSet(InternalEObject eObject, EStructuralFeature feature)
    protected boolean delegateEquals(Object object)
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      return getValue(eObject, dynamicFeatureID) != null;
        return true;
      }

      if (!(object instanceof List))
      {
        return false;
      }

      List<?> list = (List<?>)object;
      if (list.size() != delegateSize())
      {
        return false;
      }

      for (ListIterator<?> i = list.listIterator(); i.hasNext();)
      {
        Object element = i.next();
        if (element == null ? get(i.previousIndex()) != null : !element.equals(get(i.previousIndex())))
        {
          return false;
        }
      }

      return true;
    }

    public void unset(InternalEObject eObject, EStructuralFeature feature)
    protected String delegateToString()
    {
      int dynamicFeatureID = eDynamicFeatureID(eObject, feature);
      setValue(eObject, dynamicFeatureID, null);
      for (int i = 0, size = size(); i < size;)
      {
        Object value = delegateGet(i);
        stringBuffer.append(String.valueOf(value));
        if (++i < size)
        {
          stringBuffer.append(", ");
        }
      }
      stringBuffer.append("]");
      return stringBuffer.toString();
    }
  }


    @Override
    protected void delegateAdd(int index, Entry object)
    {
      eStore().add(owner, eStructuralFeature, index, object);
    }

    @Override

    @Override
    protected void delegateClear()
    {
      eStore().clear(owner, eStructuralFeature);
    }

    @Override
    protected boolean delegateContains(Object object)
    {
      return eStore().contains(owner, eStructuralFeature, object);
    }

    @Override

    @Override
    protected Entry delegateGet(int index)
    {
      return (Entry)eStore().get(owner, eStructuralFeature, index);
    }

    @Override
    protected int delegateHashCode()
    {
      return eStore().hashCode(owner, eStructuralFeature);
    }

    @Override
    protected int delegateIndexOf(Object object)
    {
      return eStore().indexOf(owner, eStructuralFeature, object);
    }

    @Override
    protected boolean delegateIsEmpty()
    {
      return eStore().isEmpty(owner, eStructuralFeature);
    }

    @Override

    @Override
    protected int delegateLastIndexOf(Object object)
    {
      return eStore().lastIndexOf(owner, eStructuralFeature, object);
    }

    @Override

    @Override
    protected Entry delegateRemove(int index)
    {
      return (Entry)eStore().remove(owner, eStructuralFeature, index);
    }

    @Override
    protected Entry delegateSet(int index, Entry object)
    {
      return (Entry)eStore().set(owner, eStructuralFeature, index, object);
    }

    @Override
    protected int delegateSize()
    {
      return eStore().size(owner, eStructuralFeature);
    }

    @Override
    protected Object[] delegateToArray()
    {
      return eStore().toArray(owner, eStructuralFeature);
    }

    @Override
    protected <T> T[] delegateToArray(T[] array)
    {
      return eStore().toArray(owner, eStructuralFeature, array);
    }

    @Override
    protected Entry delegateMove(int targetIndex, int sourceIndex)
    {
      return (Entry)eStore().move(owner, eStructuralFeature, targetIndex, sourceIndex);
    }

    @Override

Return to bug 251544

Lines 165-196 Link Here

(-)src/org/eclipse/emf/cdo/CDOView.java (-26 lines)
165	public boolean hasConflict();	165	public boolean hasConflict();
166		166
167	/**	167	/**
168	* @see #setUniqueResourceContents(boolean)
169	* @deprecated This performance tweak is not necessary with EMF 2.5 anymore and is likely to be removed when CDO
170	* reaches 2.0. In the meantime it can be safely used.
171	*/
172	@Deprecated
173	public boolean hasUniqueResourceContents();
174
175	/**
176	* Specifies whether the contents list of resources will be unique or not.
177	* <p>
178	* This property is transient in that it does not stick with resources outside of the scope of this view. Especially
179	* it will not be persisted with resources in the repository. Each new view will start with <code>true</code> as a
180	* default value. Changing to <code>false</code> will subsequently apply to all resources being loaded or created.
181	* <p>
182	* Notice that the resource contents is a containment list and as such <b>must be</b> unique. Setting this property to
183	* <code>false</code> is only recommended for performance optimization when uniqueness is granted by other means.
184	* Violating the uniqueness constraint will result in unpredictable behaviour and possible corruption of the
185	* repository!
186	*
187	* @deprecated This performance tweak is not necessary with EMF 2.5 anymore and is likely to be removed when CDO
188	* reaches 2.0. In the meantime it can be safely used.
189	*/
190	@Deprecated
191	public void setUniqueResourceContents(boolean uniqueResourceContents);
192
193	/**
194	* Returns <code>true</code> if the {@link CDOObject objects} in this view will notify their	168	* Returns <code>true</code> if the {@link CDOObject objects} in this view will notify their
195	* {@link org.eclipse.emf.common.notify.Adapter adapters} about the fact that they are <em>invalidated</em> (due to	169	* {@link org.eclipse.emf.common.notify.Adapter adapters} about the fact that they are <em>invalidated</em> (due to
196	* remote changes), <code>false</code> otherwise.	170	* remote changes), <code>false</code> otherwise.

Lines 100-107 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOViewImpl.java (-14 lines)
100		100
101	private CDOURIHandler uriHandler = new CDOURIHandler(this);	101	private CDOURIHandler uriHandler = new CDOURIHandler(this);
102		102
103	private boolean uniqueResourceContents = true;
104
105	private boolean invalidationNotificationEnabled;	103	private boolean invalidationNotificationEnabled;
106		104
107	private CDORevisionPrefetchingPolicy revisionPrefetchingPolicy;	105	private CDORevisionPrefetchingPolicy revisionPrefetchingPolicy;
Lines 225-242 Link Here
225	return false;	223	return false;
226	}	224	}
227		225
228	@Deprecated
229	public boolean hasUniqueResourceContents()
230	{
231	return uniqueResourceContents;
232	}
233
234	@Deprecated
235	public void setUniqueResourceContents(boolean uniqueResourceContents)
236	{
237	this.uniqueResourceContents = uniqueResourceContents;
238	}
239
240	/**	226	/**
241	* @since 2.0	227	* @since 2.0
242	*/	228	*/

Added Link Here

(-)src/org/eclipse/emf/cdo/tests/bugzilla/Bugzilla_251544_Test.java (+64 lines)
1	package org.eclipse.emf.cdo.tests.bugzilla;
2
3	import org.eclipse.emf.cdo.CDOSession;
4	import org.eclipse.emf.cdo.CDOTransaction;
5	import org.eclipse.emf.cdo.eresource.CDOResource;
6	import org.eclipse.emf.cdo.tests.AbstractCDOTest;
7	import org.eclipse.emf.cdo.tests.model1.Order;
8	import org.eclipse.emf.cdo.tests.model1.OrderDetail;
9
10	import org.eclipse.emf.common.util.EList;
11	import org.eclipse.emf.ecore.EObject;
12
13	/**
14	* Resources fetched using CDOViewImpl.getResource(CDOID) not added to ResourceSet
15	* <p>
16	* See https://bugs.eclipse.org/251544
17	*
18	* @author Simon McDuff
19	*/
20	public class Bugzilla_251544_Test extends AbstractCDOTest
21	{
22	public void testFromPersistedToTransient() throws Exception
23	{
24	CDOSession session = openModel1Session();
25	CDOTransaction transaction = session.openTransaction();
26	CDOResource resource = transaction.createResource("/my/resource");
27
28	Order order1 = getModel1Factory().createOrder();
29	OrderDetail orderDetail = getModel1Factory().createOrderDetail();
30	EList<EObject> contentList = resource.getContents();
31	resource.getContents().add(order1);
32	order1.getOrderDetails().add(orderDetail);
33	EList<OrderDetail> list = order1.getOrderDetails();
34	resource.getContents().remove(0); // remove object by index
35	list.remove(orderDetail);
36
37	transaction.commit();
38
39	resource.delete(null);
40
41	assertSame(contentList, resource.getContents());
42	}
43
44	public void testFromTransientToPersisted() throws Exception
45	{
46	CDOSession session = openModel1Session();
47	CDOTransaction transaction = session.openTransaction();
48	CDOResource resource = transaction.createResource("/my/resource");
49
50	Order order1 = getModel1Factory().createOrder();
51	OrderDetail orderDetail = getModel1Factory().createOrderDetail();
52	EList<OrderDetail> orderDetails = order1.getOrderDetails();
53	order1.getOrderDetails().add(orderDetail);
54
55	msg("Persist the graph");
56	resource.getContents().add(order1);
57	assertSame(orderDetails, order1.getOrderDetails());
58	resource.getContents().remove(0); // remove object by index
59	assertSame(orderDetails, order1.getOrderDetails());
60	assertEquals(true, orderDetails.remove(orderDetail));
61	transaction.commit();
62	}
63
64	}

Lines 48-59 Link Here

(-)src/org/eclipse/emf/cdo/eresource/impl/CDOResourceImpl.java (-166 / +63 lines)
48	import org.eclipse.emf.ecore.resource.impl.ExtensibleURIConverterImpl;	48	import org.eclipse.emf.ecore.resource.impl.ExtensibleURIConverterImpl;
49	import org.eclipse.emf.ecore.resource.impl.ResourceImpl;	49	import org.eclipse.emf.ecore.resource.impl.ResourceImpl;
50	import org.eclipse.emf.ecore.util.InternalEList;	50	import org.eclipse.emf.ecore.util.InternalEList;
51	import org.eclipse.emf.ecore.util.NotifyingInternalEListImpl;
52		51
53	import java.io.IOException;	52	import java.io.IOException;
54	import java.io.InputStream;	53	import java.io.InputStream;
55	import java.io.OutputStream;	54	import java.io.OutputStream;
56	import java.util.Collection;
57	import java.util.Iterator;	55	import java.util.Iterator;
58	import java.util.Map;	56	import java.util.Map;
59		57
Lines 257-274 Link Here
257	@SuppressWarnings("unchecked")	255	@SuppressWarnings("unchecked")
258	public EList<EObject> getContents()	256	public EList<EObject> getContents()
259	{	257	{
260	if (FSMUtil.isTransient(this))	258	/*
261	{	259	* if (FSMUtil.isTransient(this)) { EList<EObject> transientContents =
262	EList<EObject> transientContents = (EList<EObject>)eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS];	260	* (EList<EObject>)eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS]; if (transientContents == null) {
263	if (transientContents == null)	261	* transientContents = new TransientContents<EObject>(); eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS] =
264	{	262	* transientContents; // throw new ImplementationError(); } return transientContents; }
265	transientContents = new TransientContents<EObject>();	263	*/
266	eSettings[EresourcePackage.CDO_RESOURCE__CONTENTS] = transientContents;
267	// throw new ImplementationError();
268	}
269
270	return transientContents;
271	}
272		264
273	return (EList<EObject>)eGet(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS, true);	265	return (EList<EObject>)eGet(EresourcePackage.Literals.CDO_RESOURCE__CONTENTS, true);
274	}	266	}
Lines 846-852 Link Here
846	{	838	{
847	if (eStructuralFeature == EresourcePackage.eINSTANCE.getCDOResource_Contents())	839	if (eStructuralFeature == EresourcePackage.eINSTANCE.getCDOResource_Contents())
848	{	840	{
849	return new PersistentContents(eStructuralFeature);	841	return new CDOContentEList(eStructuralFeature);
850	}	842	}
851		843
852	return super.createList(eStructuralFeature);	844	return super.createList(eStructuralFeature);
Lines 857-875 Link Here
857	*	849	*
858	* @ADDED	850	* @ADDED
859	* @author Eike Stepper	851	* @author Eike Stepper
		852	* @since 2.0
860	*/	853	*/
861	protected class PersistentContents extends CDOStoreEList<Object>	854	protected class CDOContentEList extends BasicEStoreEList<Object>
862	{	855	{
863	private static final long serialVersionUID = 1L;	856	private static final long serialVersionUID = 1L;
864		857
865	@SuppressWarnings("deprecation")	858	public CDOContentEList(EStructuralFeature eStructuralFeature)
866	public PersistentContents(EStructuralFeature eStructuralFeature)
867	{	859	{
868	super(eStructuralFeature);	860	super(CDOResourceImpl.this, eStructuralFeature);
869	if (!cdoView().hasUniqueResourceContents())
870	{
871	kind &= ~IS_UNIQUE;
872	}
873	}	861	}
874		862
875	/**	863	/**
Lines 890-904 Link Here
890	@Override	878	@Override
891	public NotificationChain inverseAdd(Object object, NotificationChain notifications)	879	public NotificationChain inverseAdd(Object object, NotificationChain notifications)
892	{	880	{
893	CDOTransactionImpl transaction = cdoView().toTransaction();	881	if (FSMUtil.isTransient(CDOResourceImpl.this))
894	InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
895	notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications);
896	// Attach here instead of i CDOObjectImpl.eSetResource because EMF does it also here
897	if (FSMUtil.isTransient(cdoObject))
898	{	882	{
899	attached(cdoObject, transaction);	883	InternalEObject eObject = (InternalEObject)object;
		884	notifications = eObject.eSetResource(CDOResourceImpl.this, notifications);
		885	}
		886	else
		887	{
		888	CDOTransactionImpl transaction = cdoView().toTransaction();
		889	InternalCDOObject cdoObject = FSMUtil.adapt(object, transaction);
		890	notifications = cdoObject.eSetResource(CDOResourceImpl.this, notifications);
		891	// Attach here instead of i CDOObjectImpl.eSetResource because EMF does it also here
		892	if (FSMUtil.isTransient(cdoObject))
		893	{
		894	attached(cdoObject, transaction);
		895	}
900	}	896	}
901
902	return notifications;	897	return notifications;
903	}	898	}
904		899
Lines 908-1054 Link Here
908	@Override	903	@Override
909	public NotificationChain inverseRemove(Object object, NotificationChain notifications)	904	public NotificationChain inverseRemove(Object object, NotificationChain notifications)
910	{	905	{
911	InternalEObject eObject = (InternalEObject)object;	906	if (FSMUtil.isTransient(CDOResourceImpl.this))
912	detached(eObject);
913	return eObject.eSetResource(null, notifications);
914	}
915	}
916
917	/**
918	* TODO Change superclass to NotifyingInternalEListImpl when EMF 2.3 is out of maintenance
919	* <p>
920	* TODO Reuse {@link ResourceImpl.ContentsEList}!!! --> Bugzilla!
921	*
922	* @ADDED
923	* @author Eike Stepper
924	*/
925	protected class TransientContents<E extends Object & EObject> extends NotifyingInternalEListImpl<E>
926	{
927	private static final long serialVersionUID = 1L;
928
929	public TransientContents()
930	{
931	}
932
933	public TransientContents(Collection<? extends E> collection)
934	{
935	super(collection);
936	}
937
938	public TransientContents(int initialCapacity)
939	{
940	super(initialCapacity);
941	}
942
943	/**
944	* Optimization taken from ResourceImpl.EContentList.contains
945	*
946	* @since 2.0
947	*/
948	@Override
949	public boolean contains(Object object)
950	{
951	return size <= 4 ? super.contains(object) : object instanceof InternalEObject
952	&& ((InternalEObject)object).eDirectResource() == CDOResourceImpl.this;
953	}
954
955	@Override
956	public Object getNotifier()
957	{
958	return CDOResourceImpl.this;
959	}
960
961	@Override
962	public int getFeatureID()
963	{
964	return EresourcePackage.CDO_RESOURCE__CONTENTS;
965	}
966
967	@Override
968	protected boolean isNotificationRequired()
969	{
970	return eNotificationRequired();
971	}
972
973	@Override
974	protected boolean useEquals()
975	{
976	return false;
977	}
978
979	@Override
980	protected boolean hasInverse()
981	{
982	return true;
983	}
984
985	@Override
986	protected boolean isUnique()
987	{
988	return true;
989	}
990
991	/**
992	* @since 2.0
993	*/
994	/*
995	* IMPORTANT: Compile errors in this method might indicate an old version of EMF. Legacy support is only enabled for
996	* EMF with fixed bug #247130. These compile errors do not affect native models!
997	*/
998	public InternalEList<E> readWriteFiringList()
999	{
1000	return this;
1001	}
1002
1003	@Override
1004	public NotificationChain inverseAdd(E object, NotificationChain notifications)
1005	{
1006	InternalEObject eObject = (InternalEObject)object;
1007	notifications = eObject.eSetResource(CDOResourceImpl.this, notifications);
1008	// CDOResourceImpl.this.attached(eObject);
1009	return notifications;
1010	}
1011
1012	@Override
1013	public NotificationChain inverseRemove(E object, NotificationChain notifications)
1014	{
1015	InternalEObject eObject = (InternalEObject)object;
1016	// CDOResourceImpl.this.detached(eObject);
1017	return eObject.eSetResource(null, notifications);
1018	}
1019
1020	@Override
1021	protected void didAdd(int index, E object)
1022	{
1023	super.didAdd(index, object);
1024	modified();
1025	}
1026
1027	@Override
1028	protected void didRemove(int index, E object)
1029	{
1030	super.didRemove(index, object);
1031	modified();
1032	}
1033
1034	@Override
1035	protected void didSet(int index, E newObject, E oldObject)
1036	{
1037	super.didSet(index, newObject, oldObject);
1038	modified();
1039	}
1040
1041	@Override
1042	protected void didClear(int oldSize, Object[] oldData)
1043	{
1044	if (oldSize == 0)
1045	{	907	{
1046	loaded();	908	InternalEObject eObject = (InternalEObject)object;
		909	notifications = eObject.eSetResource(null, notifications);
1047	}	910	}
1048	else	911	else
1049	{	912	{
1050	super.didClear(oldSize, oldData);	913	InternalEObject eObject = (InternalEObject)object;
		914	detached(eObject);
		915	notifications = eObject.eSetResource(null, notifications);
1051	}	916	}
		917	return notifications;
1052	}	918	}
1053		919
1054	/**	920	/**
Lines 1066-1071 Link Here
1066	}	932	}
1067	}	933	}
1068		934
		935	/**
		936	* @since 2.0
		937	*/
1069	protected void modified()	938	protected void modified()
1070	{	939	{
1071	if (isTrackingModification())	940	if (isTrackingModification())
Lines 1073-1077 Link Here
1073	setModified(true);	942	setModified(true);
1074	}	943	}
1075	}	944	}
		945
		946	/**
		947	* @since 2.0
		948	*/
		949	@Override
		950	protected boolean useEquals()
		951	{
		952	return false;
		953	}
		954
		955	/**
		956	* @since 2.0
		957	*/
		958	@Override
		959	protected boolean hasInverse()
		960	{
		961	return true;
		962	}
		963
		964	/**
		965	* @since 2.0
		966	*/
		967	@Override
		968	protected boolean isUnique()
		969	{
		970	return true;
		971	}
1076	}	972	}
		973
1077	} // CDOResourceImpl	974	} // CDOResourceImpl