Attachment #115825 for bug #251544

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




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
   */

Lines 30-36 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOXATransactionCommitContext.java (-2 / +1 lines)
30	import java.util.HashMap;	30	import java.util.HashMap;
31	import java.util.List;	31	import java.util.List;
32	import java.util.Map;	32	import java.util.Map;
33	import java.util.Set;
34	import java.util.concurrent.Callable;	33	import java.util.concurrent.Callable;
35		34
36	/**	35	/**
Lines 112-118 Link Here
112	return delegateCommitContext.getNewResources();	111	return delegateCommitContext.getNewResources();
113	}	112	}
114		113
115	public Set<CDOID> getDetachedObjects()	114	public Map<CDOID, CDOObject> getDetachedObjects()
116	{	115	{
117	return delegateCommitContext.getDetachedObjects();	116	return delegateCommitContext.getDetachedObjects();
118	}	117	}




import org.eclipse.emf.internal.cdo.bundle.OM;
import org.eclipse.emf.internal.cdo.protocol.CommitTransactionResult;
import org.eclipse.emf.internal.cdo.util.CompletePackageClosure;
import org.eclipse.emf.internal.cdo.util.FSMUtil;
import org.eclipse.emf.internal.cdo.util.IPackageClosure;
import org.eclipse.emf.internal.cdo.util.ModelUtil;


  /**
   * @since 2.0
   */
  @Override
  public InternalCDOObject getObject(CDOID id, boolean loadOnDemand)
  {
    checkOpen();
    if (id == null || id.isNull())
    {
      return null;
    }

    if (isDetached(id))
    {
      FSMUtil.validate(id, null);
    }

    return super.getObject(id, loadOnDemand);
  }

  /**
   * @since 2.0
   */
  public CDOCommitContext createCommitContext()
  {
    return new CDOCommitContextImpl();

          {
            InternalCDOObject internalDirtyObject = (InternalCDOObject)entryDirty.getValue();
            cleanObject(internalDirtyObject, getRevision(entryDirty.getKey(), true));
            // registerObject(internalDirtyObject);
          }
        }
      }

    for (Entry<CDOID, CDOObject> entryNewObject : newObjMaps.entrySet())
    {
      InternalCDOObject object = (InternalCDOObject)entryNewObject.getValue();
      if (!isObjectRegistered(entryNewObject.getKey()))
      {
        registerObject(object);
      }

      // Go back to the previous state
      cleanObject(object, (InternalCDORevision)object.cdoRevision());

    }

    // deregister object
    // deregisterObject(object);

    if (object.cdoState() == CDOState.NEW)
    {


    private Map<CDOID, CDORevisionDelta> revisionDeltas;

    private Map<CDOID, CDOObject> detachedObjects;

    private List<CDOPackage> newPackages;


      newResources = transaction.getNewResources();
      newObjects = transaction.getNewObjects();
      dirtyObjects = transaction.getDirtyObjects();
      detachedObjects = transaction.getDetachedObjects();
      revisionDeltas = transaction.getRevisionDeltas();
      newPackages = transaction.analyzeNewPackages();
    }

      return newResources;
    }

    public Map<CDOID, CDOObject> getDetachedObjects()
    {
      return detachedObjects;
    }

          postCommit(getNewResources(), result);
          postCommit(getNewObjects(), result);
          postCommit(getDirtyObjects(), result);
          for (Entry<CDOID, CDOObject> entry : getDetachedObjects().entrySet())
          {
            removeObject(entry.getKey());
          }
          CDOSessionImpl session = getTransaction().getSession();

          for (CDOPackage newPackage : newPackages)

          ChangeSubscriptionManager changeSubscriptionManager = getTransaction().getChangeSubscriptionManager();
          changeSubscriptionManager.handleNewObjects(getNewObjects().values());
          changeSubscriptionManager.handleNewObjects(getNewResources().values());
          changeSubscriptionManager.handleDetachedObjects(getDetachedObjects().keySet());

          long timeStamp = result.getTimeStamp();



          if (!dirtyIDs.isEmpty() || !getDetachedObjects().isEmpty())
          {
            Set<CDOID> detachedIDs = new HashSet<CDOID>(getDetachedObjects().keySet());
            Collection<CDORevisionDelta> deltasCopy = new ArrayList<CDORevisionDelta>(deltas);
            session.handleCommitNotification(timeStamp, dirtyIDs, detachedIDs, deltasCopy, getTransaction());
          }




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

Lines 21-27 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOCommitContext.java (-2 / +1 lines)
21		21
22	import java.util.List;	22	import java.util.List;
23	import java.util.Map;	23	import java.util.Map;
24	import java.util.Set;
25		24
26	/**	25	/**
27	* Provides a context for a commit operation.	26	* Provides a context for a commit operation.
Lines 45-51 Link Here
45		44
46	public Map<CDOID, CDOObject> getDirtyObjects();	45	public Map<CDOID, CDOObject> getDirtyObjects();
47		46
48	public Set<CDOID> getDetachedObjects();	47	public Map<CDOID, CDOObject> getDetachedObjects();
49		48
50	public Map<CDOID, CDORevisionDelta> getRevisionDeltas();	49	public Map<CDOID, CDORevisionDelta> getRevisionDeltas();
51	}	50	}

Lines 103-109 Link Here

(-)src/org/eclipse/emf/internal/cdo/protocol/CommitTransactionRequest.java (-1 / +1 lines)
103	Collection<CDOResource> newResources = commitContext.getNewResources().values();	103	Collection<CDOResource> newResources = commitContext.getNewResources().values();
104	Collection<CDOObject> newObjects = commitContext.getNewObjects().values();	104	Collection<CDOObject> newObjects = commitContext.getNewObjects().values();
105	Collection<CDORevisionDelta> revisionDeltas = commitContext.getRevisionDeltas().values();	105	Collection<CDORevisionDelta> revisionDeltas = commitContext.getRevisionDeltas().values();
106	Collection<CDOID> detachedObjects = commitContext.getDetachedObjects();	106	Collection<CDOID> detachedObjects = commitContext.getDetachedObjects().keySet();
107		107
108	out.writeInt(newPackages.size());	108	out.writeInt(newPackages.size());
109	out.writeInt(newResources.size() + newObjects.size());	109	out.writeInt(newResources.size() + newObjects.size());

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	*/

Lines 44-50 Link Here

(-)src/org/eclipse/emf/internal/cdo/CDOTransactionImpl.java (-33 / +11 lines)
44	import org.eclipse.emf.internal.cdo.bundle.OM;	44	import org.eclipse.emf.internal.cdo.bundle.OM;
45	import org.eclipse.emf.internal.cdo.protocol.CommitTransactionResult;	45	import org.eclipse.emf.internal.cdo.protocol.CommitTransactionResult;
46	import org.eclipse.emf.internal.cdo.util.CompletePackageClosure;	46	import org.eclipse.emf.internal.cdo.util.CompletePackageClosure;
47	import org.eclipse.emf.internal.cdo.util.FSMUtil;
48	import org.eclipse.emf.internal.cdo.util.IPackageClosure;	47	import org.eclipse.emf.internal.cdo.util.IPackageClosure;
49	import org.eclipse.emf.internal.cdo.util.ModelUtil;	48	import org.eclipse.emf.internal.cdo.util.ModelUtil;
50		49
Lines 407-432 Link Here
407	/**	406	/**
408	* @since 2.0	407	* @since 2.0
409	*/	408	*/
410	@Override
411	public InternalCDOObject getObject(CDOID id, boolean loadOnDemand)
412	{
413	checkOpen();
414	if (id == null \|\| id.isNull())
415	{
416	return null;
417	}
418
419	if (isDetached(id))
420	{
421	FSMUtil.validate(id, null);
422	}
423
424	return super.getObject(id, loadOnDemand);
425	}
426
427	/**
428	* @since 2.0
429	*/
430	public CDOCommitContext createCommitContext()	409	public CDOCommitContext createCommitContext()
431	{	410	{
432	return new CDOCommitContextImpl();	411	return new CDOCommitContextImpl();
Lines 519-525 Link Here
519	{	498	{
520	InternalCDOObject internalDirtyObject = (InternalCDOObject)entryDirty.getValue();	499	InternalCDOObject internalDirtyObject = (InternalCDOObject)entryDirty.getValue();
521	cleanObject(internalDirtyObject, getRevision(entryDirty.getKey(), true));	500	cleanObject(internalDirtyObject, getRevision(entryDirty.getKey(), true));
522	registerObject(internalDirtyObject);	501	// registerObject(internalDirtyObject);
523	}	502	}
524	}	503	}
525	}	504	}
Lines 585-594 Link Here
585	for (Entry<CDOID, CDOObject> entryNewObject : newObjMaps.entrySet())	564	for (Entry<CDOID, CDOObject> entryNewObject : newObjMaps.entrySet())
586	{	565	{
587	InternalCDOObject object = (InternalCDOObject)entryNewObject.getValue();	566	InternalCDOObject object = (InternalCDOObject)entryNewObject.getValue();
588	if (!isObjectRegistered(entryNewObject.getKey()))
589	{
590	registerObject(object);
591	}
592		567
593	// Go back to the previous state	568	// Go back to the previous state
594	cleanObject(object, (InternalCDORevision)object.cdoRevision());	569	cleanObject(object, (InternalCDORevision)object.cdoRevision());
Lines 648-654 Link Here
648	}	623	}
649		624
650	// deregister object	625	// deregister object
651	deregisterObject(object);	626	// deregisterObject(object);
652		627
653	if (object.cdoState() == CDOState.NEW)	628	if (object.cdoState() == CDOState.NEW)
654	{	629	{
Lines 1017-1023 Link Here
1017		992
1018	private Map<CDOID, CDORevisionDelta> revisionDeltas;	993	private Map<CDOID, CDORevisionDelta> revisionDeltas;
1019		994
1020	private Set<CDOID> detachedObjects;	995	private Map<CDOID, CDOObject> detachedObjects;
1021		996
1022	private List<CDOPackage> newPackages;	997	private List<CDOPackage> newPackages;
1023		998
Lines 1027-1033 Link Here
1027	newResources = transaction.getNewResources();	1002	newResources = transaction.getNewResources();
1028	newObjects = transaction.getNewObjects();	1003	newObjects = transaction.getNewObjects();
1029	dirtyObjects = transaction.getDirtyObjects();	1004	dirtyObjects = transaction.getDirtyObjects();
1030	detachedObjects = transaction.getDetachedObjects().keySet();	1005	detachedObjects = transaction.getDetachedObjects();
1031	revisionDeltas = transaction.getRevisionDeltas();	1006	revisionDeltas = transaction.getRevisionDeltas();
1032	newPackages = transaction.analyzeNewPackages();	1007	newPackages = transaction.analyzeNewPackages();
1033	}	1008	}
Lines 1052-1058 Link Here
1052	return newResources;	1027	return newResources;
1053	}	1028	}
1054		1029
1055	public Set<CDOID> getDetachedObjects()	1030	public Map<CDOID, CDOObject> getDetachedObjects()
1056	{	1031	{
1057	return detachedObjects;	1032	return detachedObjects;
1058	}	1033	}
Lines 1109-1115 Link Here
1109	postCommit(getNewResources(), result);	1084	postCommit(getNewResources(), result);
1110	postCommit(getNewObjects(), result);	1085	postCommit(getNewObjects(), result);
1111	postCommit(getDirtyObjects(), result);	1086	postCommit(getDirtyObjects(), result);
1112		1087	for (Entry<CDOID, CDOObject> entry : getDetachedObjects().entrySet())
		1088	{
		1089	removeObject(entry.getKey());
		1090	}
1113	CDOSessionImpl session = getTransaction().getSession();	1091	CDOSessionImpl session = getTransaction().getSession();
1114		1092
1115	for (CDOPackage newPackage : newPackages)	1093	for (CDOPackage newPackage : newPackages)
Lines 1120-1126 Link Here
1120	ChangeSubscriptionManager changeSubscriptionManager = getTransaction().getChangeSubscriptionManager();	1098	ChangeSubscriptionManager changeSubscriptionManager = getTransaction().getChangeSubscriptionManager();
1121	changeSubscriptionManager.handleNewObjects(getNewObjects().values());	1099	changeSubscriptionManager.handleNewObjects(getNewObjects().values());
1122	changeSubscriptionManager.handleNewObjects(getNewResources().values());	1100	changeSubscriptionManager.handleNewObjects(getNewResources().values());
1123	changeSubscriptionManager.handleDetachedObjects(getDetachedObjects());	1101	changeSubscriptionManager.handleDetachedObjects(getDetachedObjects().keySet());
1124		1102
1125	long timeStamp = result.getTimeStamp();	1103	long timeStamp = result.getTimeStamp();
1126		1104
Lines 1135-1141 Link Here
1135		1113
1136	if (!dirtyIDs.isEmpty() \|\| !getDetachedObjects().isEmpty())	1114	if (!dirtyIDs.isEmpty() \|\| !getDetachedObjects().isEmpty())
1137	{	1115	{
1138	Set<CDOID> detachedIDs = new HashSet<CDOID>(getDetachedObjects());	1116	Set<CDOID> detachedIDs = new HashSet<CDOID>(getDetachedObjects().keySet());
1139	Collection<CDORevisionDelta> deltasCopy = new ArrayList<CDORevisionDelta>(deltas);	1117	Collection<CDORevisionDelta> deltasCopy = new ArrayList<CDORevisionDelta>(deltas);
1140	session.handleCommitNotification(timeStamp, dirtyIDs, detachedIDs, deltasCopy, getTransaction());	1118	session.handleCommitNotification(timeStamp, dirtyIDs, detachedIDs, deltasCopy, getTransaction());
1141	}	1119	}

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