/******************************************************************************
* Copyright (c) 2006, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
****************************************************************************/
package org.eclipse.gmf.runtime.emf.core.util;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.common.notify.Notifier;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.EStructuralFeature.Setting;
import org.eclipse.emf.ecore.impl.EClassImpl;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EContentsEList;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
import org.eclipse.emf.ecore.util.ECrossReferenceEList;
import org.eclipse.emf.ecore.util.ExtendedMetaData;
import org.eclipse.emf.ecore.util.FeatureMapUtil;
import org.eclipse.emf.ecore.util.InternalEList;
/**
* An adapter that maintains itself as an adapter for all contained objects. It
* can be installed for an {@link EObject}, a {@link Resource}, or a
* {@link ResourceSet}.
* <p>
* This adapter maintain information on inverse references, resource imports,
* and resource exports.
*
* @author Christian Vogt (cvogt)
* @author Christian W. Damus (cdamus)
*/
public class CrossReferenceAdapter extends ECrossReferenceAdapter {
private Map imports = new HashMap();
private Map exports = new HashMap();
private boolean resolve = true;
private Map eClassToChangeableFeatures = new HashMap();
private static List nullList = new ArrayList(1);
/**
* Initializes me.
*/
public CrossReferenceAdapter() {
this(true);
}
/**
* Initializes me.
*
* @param resolve
* flag to determine if the proxies need to be resolved
*/
public CrossReferenceAdapter(boolean resolve) {
super();
this.resolve = resolve;
}
/**
* Updates imports and exports maps.
*
* @param notification
* the event notification
*/
public void selfAdapt(Notification notification) {
super.selfAdapt(notification);
Object notifier = notification.getNotifier();
Object feature = notification.getFeature();
// update import / export information when a resource
// is unloaded or loaded
if (notifier instanceof Resource) {
if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__IS_LOADED) {
if (!notification.getNewBooleanValue()) {
deregisterReferences((Resource) notifier);
} else {
for (Iterator i = ((Resource) notifier).getContents()
.iterator(); i.hasNext();) {
EObject child = (EObject) i.next();
if (child != null) {
updateImportsAndExports((Resource) notifier, child,
true);
}
}
}
}
return;
}
// interested in maintaining import / export information
// when the notifier is an EObject and the feature is a
// non-containment EReference
if (!(notifier instanceof EObject) || !(feature instanceof EReference)) {
return;
}
EReference reference = (EReference) feature;
if (!isImportExportCapable(reference, (EObject) notifier)) {
return;
}
switch (notification.getEventType()) {
case Notification.RESOLVE:
case Notification.SET:
case Notification.UNSET: {
if (!reference.isMany() || notification.getPosition() != Notification.NO_INDEX) {
EObject oldValue = (EObject) notification.getOldValue();
if (oldValue != null) {
deregisterReference(((EObject) notification.getNotifier())
.eResource(), oldValue.eResource());
}
EObject newValue = (EObject) notification.getNewValue();
if (newValue != null) {
registerReference(((EObject) notification.getNotifier())
.eResource(), newValue.eResource());
}
}
break;
}
case Notification.ADD: {
EObject newValue = (EObject) notification.getNewValue();
if (newValue != null) {
registerReference(((EObject) notification.getNotifier())
.eResource(), newValue.eResource());
}
break;
}
case Notification.ADD_MANY: {
Collection newValues = (Collection) notification.getNewValue();
for (Iterator i = newValues.iterator(); i.hasNext();) {
EObject newValue = (EObject) i.next();
registerReference(((EObject) notification.getNotifier())
.eResource(), newValue.eResource());
}
break;
}
case Notification.REMOVE: {
EObject oldValue = (EObject) notification.getOldValue();
if (oldValue != null) {
deregisterReference(((EObject) notification.getNotifier())
.eResource(), oldValue.eResource());
}
break;
}
case Notification.REMOVE_MANY: {
Collection oldValues = (Collection) notification.getOldValue();
for (Iterator i = oldValues.iterator(); i.hasNext();) {
EObject oldValue = (EObject) i.next();
deregisterReference(((EObject) notification.getNotifier())
.eResource(), oldValue.eResource());
}
break;
}
}
}
/**
* Extends the superclass method to handle the removal cases of containment,
* to tear down aggregate (resource-level) cross-references.
*/
protected void handleContainment(Notification notification) {
super.handleContainment(notification);
Object notifier = notification.getNotifier();
if (notifier instanceof ResourceSet) {
// not interested in removal of resources from the resource set
return;
}
switch (notification.getEventType()) {
case Notification.ADD: {
EObject newValue = (EObject) notification.getNewValue();
if (newValue != null) {
Resource resource;
if (notifier instanceof Resource) {
resource = (Resource) notifier;
} else {
resource = ((EObject) notification.getNotifier())
.eResource();
}
// handle processing of the new value that has been added
updateImportsAndExports(resource, newValue, true);
}
break;
}
case Notification.ADD_MANY: {
Resource resource;
if (notifier instanceof Resource) {
resource = (Resource) notifier;
} else {
resource = ((EObject) notification.getNotifier()).eResource();
}
Collection newValues = (Collection) notification.getNewValue();
for (Iterator iter = newValues.iterator(); iter.hasNext();) {
EObject next = (EObject) iter.next();
if (next != null) {
// handle processing of the new value that has been added
updateImportsAndExports(resource, next, true);
}
}
break;
}
case Notification.REMOVE: {
EObject oldValue = (EObject) notification.getOldValue();
if (oldValue != null) {
Resource resource;
if (notifier instanceof Resource) {
resource = (Resource) notifier;
} else {
resource = ((EObject) notification.getNotifier())
.eResource();
}
// handle processing of the old value that has been removed
updateImportsAndExports(resource, oldValue, false);
}
break;
}
case Notification.REMOVE_MANY: {
Resource resource;
if (notifier instanceof Resource) {
resource = (Resource) notifier;
if (!resource.isLoaded()) {
// purge the resource from the imports/exports map
deregisterReferences(resource);
return;
}
} else {
resource = ((EObject) notification.getNotifier()).eResource();
}
Collection oldValues = (Collection) notification.getOldValue();
for (Iterator iter = oldValues.iterator(); iter.hasNext();) {
EObject next = (EObject) iter.next();
if (next != null) {
// handle processing of the old value that has been removed
updateImportsAndExports(resource, next, false);
}
}
break;
}
}
}
/**
* Updates the imports and exports map for the specified eObject
*
* @param resource
* a resource
* @param eObject
* the specified eObject
* @param register
* boolean flag to indicate whether to register imports or
* unregister imports
*/
public void updateImportsAndExports(Resource resource, EObject value,
boolean register) {
CrossReferenceAdapter adapter = getExistingCrossReferenceAdapter(value);
if (register) {
if (adapter != null) {
// now, register incoming unidirectional references and
// opposites
for (Iterator iter = adapter.getInverseReferences(value).iterator();
iter.hasNext();) {
EStructuralFeature.Setting next = (EStructuralFeature.Setting) iter.next();
EReference ref = (EReference) next.getEStructuralFeature();
EObject owner = next.getEObject();
if (isImportExportCapable(ref, owner)) {
registerReference(owner.eResource(), resource);
}
}
}
} else {
// deregister the outgoing references and incoming bidirectionals
EContentsEList.FeatureIterator crossReferences = getOptimizedCrossReferenceIterator(
value);
while (crossReferences.hasNext()) {
EObject referent = (EObject) crossReferences.next();
if (referent != null) {
EReference eReference = (EReference) crossReferences
.feature();
if (isImportExportCapable(eReference, referent)) {
Resource referencedResource = referent.eResource();
deregisterReference(resource, referencedResource);
}
}
}
// now, deregister incoming unidirectional references and opposites
if (adapter != null) {
for (Iterator iter = adapter.getInverseReferences(value).iterator();
iter.hasNext();) {
EStructuralFeature.Setting next = (EStructuralFeature.Setting) iter.next();
EReference ref = (EReference) next.getEStructuralFeature();
EObject owner = next.getEObject();
if (isImportExportCapable(ref, owner)) {
deregisterReference(owner.eResource(), resource);
}
}
}
}
// process contents
if (adapter != null) {
adapter.updateImportsAndExportsForContents(resource, value,
register);
}
}
/**
* Updates the imports and exports map for the contents of the specified
* eObject
*
* @param resource
* a resource
* @param eObject
* the specified eObject
* @param register
* boolean flag to indicate whether to register imports or
* unregister imports
*/
public void updateImportsAndExportsForContents(Resource resource,
EObject value, boolean register) {
// go through the children of the eObject
for (Iterator i = resolve() ? value.eContents().iterator()
: ((InternalEList) value.eContents()).basicIterator(); i
.hasNext();) {
updateImportsAndExports(resource, (EObject) i.next(), register);
}
}
/**
* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#setTarget(org.eclipse.emf.common.notify.Notifier)
*/
public void setTarget(Notifier target) {
super.setTarget(target);
if (target instanceof EObject) {
EObject eObject = (EObject) target;
Resource resource = eObject.eResource();
// register the outgoing references and incoming bidirectionals
EContentsEList.FeatureIterator crossReferences = getOptimizedCrossReferenceIterator(
eObject);
while (crossReferences.hasNext()) {
EObject referent = (EObject) crossReferences.next();
if (referent != null) {
EReference eReference = (EReference) crossReferences
.feature();
if (isImportExportCapable(eReference, referent)) {
Resource referencedResource = referent.eResource();
registerReference(resource, referencedResource);
}
}
}
}
}
/**
* @see org.eclipse.emf.ecore.util.ECrossReferenceAdapter#unsetTarget(org.eclipse.emf.common.notify.Notifier)
*/
public void unsetTarget(Notifier notifier) {
super.unsetTarget(notifier);
if (notifier instanceof Resource) {
deregisterReferences((Resource) notifier);
}
}
/**
* Gets the imports of a resource.
*
* @param referencer
* the resource to retrieve imports for
* @return a Set of resource imports
*/
public Set getImports(Resource referencer) {
Map importsMap = getImportsMap(referencer);
if (importsMap != null) {
return Collections.unmodifiableSet(importsMap.keySet());
} else {
return Collections.EMPTY_SET;
}
}
/**
* Gets the exports of a resource.
*
* @param referenced
* the resource to retrieve exports for
* @return a Set of resource exports
*/
public Set getExports(Resource referenced) {
Map exportsMap = getExportsMap(referenced);
if (exportsMap != null) {
return Collections.unmodifiableSet(exportsMap.keySet());
} else {
return Collections.EMPTY_SET;
}
}
/**
* Returns the imports map of the given resource.
*
* @param resource
* @return imports map of the given resource
*/
private Map getImportsMap(Resource resource) {
return (Map) imports.get(resource);
}
/**
* Returns the exports map of the given resource.
*
* @param resource
* @return exports map of the given resource
*/
private Map getExportsMap(Resource resource) {
return (Map) exports.get(resource);
}
/**
* Registers a reference updating the imports and exports maps accordingly.
*
* @param referencer
* the referencing resource
* @param referenced
* the referenced resouce
*/
private void registerReference(final Resource referencer,
final Resource referenced) {
if ((referencer != null) && (referenced != null)
&& (referencer != referenced)) {
Map importsMap = getImportsMap(referencer);
if (importsMap == null) {
importsMap = new HashMap();
imports.put(referencer, importsMap);
}
Counter importsCount = (Counter) importsMap.get(referenced);
if (importsCount == null) {
importsCount = new Counter();
importsMap.put(referenced, importsCount);
importAdded(referencer, referenced);
} else {
importsCount.inc();
}
Map exportsMap = getExportsMap(referenced);
if (exportsMap == null) {
exportsMap = new HashMap();
exports.put(referenced, exportsMap);
}
Counter exportsCount = (Counter) exportsMap.get(referencer);
if (exportsCount == null) {
exportsCount = new Counter();
exportsMap.put(referencer, exportsCount);
exportAdded(referenced, referencer);
} else {
exportsCount.inc();
}
}
}
/**
* Hook to be implemented by subclasses upon the establishment of a new
* import of the <code>referenced</code> resource by the
* <code>referencer</code>. This implementation does nothing; subclasses
* need not call <code>super</code>.
*
* @param referencer
* the referencing resource (doing the importing)
* @param referenced
* the resource that it references
*/
protected void importAdded(Resource referencer, Resource referenced) {
// subclass hook
}
/**
* Hook to be implemented by subclasses upon the elimination of an import of
* the <code>referenced</code> resource by the <code>referencer</code>.
* This implementation does nothing; subclasses need not call
* <code>super</code>.
*
* @param referencer
* the formerly referencing resource (doing the importing)
* @param referenced
* the resource that it had referenced
*/
protected void importRemoved(Resource referencer, Resource referenced) {
// subclass hook
}
/**
* Hook to be implemented by subclasses upon the establishment of a new
* export of the <code>referenced</code> resource to the
* <code>referencer</code>. This implementation does nothing; subclasses
* need not call <code>super</code>.
*
* @param referenced
* the resource being referenced (doing the exporting)
* @param referencer
* the referencing resource
*/
protected void exportAdded(Resource referenced, Resource referencer) {
// subclass hook
}
/**
* Hook to be implemented by subclasses upon the elimination of an export of
* the <code>referenced</code> resource to the <code>referencer</code>.
* This implementation does nothing; subclasses need not call
* <code>super</code>.
*
* @param referenced
* the resource formerly being referenced (doing the exporting)
* @param referencer
* the formerly referencing resource
*/
protected void exportRemoved(Resource referenced, Resource referencer) {
// subclass hook
}
/**
* Deregisters a reference updating the imports and exports maps
* accordingly.
*
* @param referencer
* the referencing resource
* @param referenced
* the referenced resource
*/
private void deregisterReference(final Resource referencer,
final Resource referenced) {
if ((referencer != null) && (referenced != null)
&& (referencer != referenced)) {
Map importsMap = getImportsMap(referencer);
if (importsMap != null) {
Counter importsCount = (Counter) importsMap.get(referenced);
if ((importsCount != null) && importsCount.dec()) {
importsMap.remove(referenced);
importRemoved(referencer, referenced);
if (importsMap.isEmpty()) {
imports.remove(referencer);
}
}
}
Map exportsMap = getExportsMap(referenced);
if (exportsMap != null) {
Counter exportsCount = (Counter) exportsMap.get(referencer);
if ((exportsCount != null) && exportsCount.dec()) {
exportsMap.remove(referencer);
exportRemoved(referenced, referencer);
if (exportsMap.isEmpty()) {
exports.remove(referenced);
}
}
}
}
}
/**
* Cleans up a resource from the imports and exports maps.
*
* @param referencer
* the referencing resource
*/
private void deregisterReferences(final Resource referencer) {
Object[] resImports = getImports(referencer).toArray();
for (int i = 0; i < resImports.length; i++) {
final Resource referenced = (Resource) resImports[i];
Map importsMap = getImportsMap(referencer);
if (importsMap != null) {
importsMap.remove(referenced);
importRemoved(referencer, referenced);
if (importsMap.isEmpty()) {
imports.remove(referencer);
}
}
Map exportsMap = getExportsMap(referenced);
if (exportsMap != null) {
exportsMap.remove(referencer);
exportRemoved(referenced, referencer);
if (exportsMap.isEmpty()) {
exports.remove(referenced);
}
}
}
}
/**
* Returns a Set of EObjects that reference the given EObject. If an
* EReference is specified, the scope of the search is limited only to that
* EReference. To include all references specify a value of null. If an
* EClass type is specified, the returned Set will only include those
* referencers that match the given type. To include all types specify a
* value of null.
*
* @param referenced
* the referenced EObject
* @param reference
* the reference to find referencers on, null for any reference
* @param type
* the type of the referencers, use null for any type
* @return a Set of referencers
*/
public Set getInverseReferencers(EObject referenced, EReference reference,
EClass type) {
return getReferencers(getInverseReferences(referenced), reference, type);
}
/**
* Like the {@link #getInverseReferencers(EObject, EReference, EClass)} method,
* obtains referencing objects (optionally filtered by reference and type),
* except that it additionally only considers references that are
* {@linkplain EStructuralFeature#isChangeable() changeable} and can
* {@linkplain EReference#isResolveProxies() reference other resources}.
*
* @param referenced
* the referenced EObject
* @param reference
* the reference to find referencers on, null for any reference
* @param type
* the type of the referencers, use null for any type
* @return a Set of referencers on potentially cross-resource references
*/
public Set getInverseReferencersCrossResource(EObject referenced, EReference reference,
EClass type) {
return getReferencers(getInverseReferencesCrossResource(referenced), reference, type);
}
/**
* Like the {@link #getInverseReferences(EObject)} method,
* obtains settings implementing references to the specified object,
* except that it only considers references that are
* {@linkplain EStructuralFeature#isChangeable() changeable} and can
* {@linkplain EReference#isResolveProxies() reference other resources}.
*
* @param eObject the referenced EObject
*
* @return a collection of {@link EStructuralFeature.Setting}s on
* potentially cross-resource references
*/
public Collection getInverseReferencesCrossResource(EObject eObject) {
return getInverseReferencesCrossResource(eObject, !resolve());
}
/**
* Returns a Set of EObjects that reference the given EObject through a uni
* directional EReferences. If an EReference is specified, the scope of the
* search is limited only to that EReference. To include all references
* specify a value of null. If an EClass type is specified, the returned Set
* will only include those referencers that match the given type. To include
* all types specify a value of null.
*
* @param referenced
* the referenced EObject
* @param reference
* the reference to find referencers on, null for any reference
* @param type
* the type of the referencers, use null for any type
* @return a Set of referencers
*/
public Set getNonNavigableInverseReferencers(EObject referenced,
EReference reference, EClass type) {
return getReferencers(getNonNavigableInverseReferences(referenced),
reference, type);
}
/**
* Extracts the EObjects from the EStructuralFeature.Setting references and
* returns a filtered Set based on the given reference and type.
*
* @param references
* a collection of EStructuralFeature.Setting
* @param reference
* the reference to find referencers on, null for any reference
* @param type
* the type of the referencers, use null for any type
* @return a Set of referencers
*/
private Set getReferencers(Collection references, EReference reference,
EClass type) {
Set set = new HashSet();
if (!references.isEmpty()) {
for (Iterator iter = references.iterator(); iter.hasNext();) {
Setting setting = (Setting) iter.next();
if (reference == null
|| reference == setting.getEStructuralFeature()) {
EObject referencer = setting.getEObject();
if (referencer != null
&& (type == null || type.isInstance(referencer))) {
set.add(referencer);
}
}
}
}
return set;
}
/**
* Searches the adapter list of the given Notifier for a
* CrossReferenceAdapter. If not found, returns null.
*
* @param notifier
* the notifier to search
* @return the CrossReferenceAdapter if found, otherwise null
*/
public static CrossReferenceAdapter getExistingCrossReferenceAdapter(
Notifier notifier) {
if (notifier == null) {
return null;
}
List adapters = notifier.eAdapters();
for (int i = 0, size = adapters.size(); i < size; ++i) {
Adapter adapter = (Adapter) adapters.get(i);
if (adapter instanceof CrossReferenceAdapter) {
return (CrossReferenceAdapter) adapter;
}
}
return null;
}
/**
* Obtains the cross-reference adapter for the specified resource set, if
* necessary creating it and attaching it.
*
* @param resourceSet
* the resource set
*
* @return the resourceSet's cross-reference adapter
*/
public static CrossReferenceAdapter getCrossReferenceAdapter(
ResourceSet resourceSet) {
if (resourceSet == null) {
return null;
}
CrossReferenceAdapter result = getExistingCrossReferenceAdapter(resourceSet);
if (result == null) {
result = new CrossReferenceAdapter();
resourceSet.eAdapters().add(result);
}
return result;
}
/**
* A mutable integer used to count number of object-level references between
* two resources.
*
* @author Christian W. Damus (cdamus)
*/
private static final class Counter {
private int value = 1;
Counter() {
super();
}
/**
* Increments me.
*/
void inc() {
value++;
}
/**
* Decrements me.
*
* @return <code>true</code> if I am now zero; <code>false</code>,
* otherwise
*/
boolean dec() {
return --value <= 0;
}
}
protected boolean resolve() {
return this.resolve;
}
public Collection getInverseReferences(EObject eObject, boolean _resolve) {
Collection result = new ArrayList();
if (_resolve) {
resolveAll(eObject);
}
EObject eContainer = eObject.eContainer();
if (eContainer != null) {
result.add(((InternalEObject) eContainer).eSetting(eObject
.eContainmentFeature()));
}
Collection nonNavigableInverseReferences = (Collection) inverseCrossReferencer
.get(eObject);
if (nonNavigableInverseReferences != null) {
result.addAll(nonNavigableInverseReferences);
}
for (Iterator i = eObject.eClass().getEAllReferences().iterator(); i
.hasNext();) {
EReference eReference = (EReference) i.next();
EReference eOpposite = eReference.getEOpposite();
if (eOpposite != null && !eReference.isContainer()
&& !eReference.isContainment()
&& eObject.eIsSet(eReference)) {
if (FeatureMapUtil.isMany(eObject, eReference)) {
Object collection = eObject.eGet(eReference);
for (Iterator j = resolve() ? ((Collection) collection)
.iterator() : ((InternalEList) collection)
.basicIterator(); j.hasNext();) {
InternalEObject referencingEObject = (InternalEObject) j
.next();
result.add(referencingEObject.eSetting(eOpposite));
}
} else {
// although the reference is set, the value could be null
InternalEObject referencingEObject = ((InternalEObject) eObject
.eGet(eReference, resolve()));
if (referencingEObject != null) {
result.add(referencingEObject.eSetting(eOpposite));
}
}
}
}
return result;
}
/**
* Computes the references defined by the specified EClass that are
* {@linkplain EStructuralFeature#isChangeable() changeable}.
*
* @param eCls an EClass
* @return a list of its {@link EReference}s that are changeable
*/
private List getCrossReferencesChangeableFeatures(EClass eCls) {
List features = (List) eClassToChangeableFeatures.get(eCls);
if (features == null) {
features = nullList;
EStructuralFeature[] crossReferenceFeatures =
((EClassImpl.FeatureSubsetSupplier) eCls
.getEAllStructuralFeatures()).crossReferences();
if (crossReferenceFeatures != null) {
features = new ArrayList(crossReferenceFeatures.length);
for (int i = 0; i < crossReferenceFeatures.length; i++) {
EStructuralFeature feature = crossReferenceFeatures[i];
if (isMutable(feature))
features.add(feature);
}
}
eClassToChangeableFeatures.put(eCls, features);
}
return features != nullList ? features
: null;
}
/**
* Queries whether a feature is mutable. A feature is considered
* mutable if and only if it is changeable and it is either not derived
* or it is a member of a feature map (though not itself a feature map).
*
* @param feature the feature to test
*
* @return <code>true</code> if the reference is mutable;
* <code>false</code>, otherwise
*/
static boolean isMutable(EStructuralFeature feature) {
boolean result = feature.isChangeable();
if (result) {
if (feature.isDerived()) {
// check whether it is a feature-map member that is not, itself,
// a feature map
EStructuralFeature group = ExtendedMetaData.INSTANCE.getGroup(feature);
result = (group != null) && !FeatureMapUtil.isFeatureMap(feature);
}
}
return result;
}
/**
* An iterator over the references defined by the specified EObject that
* are {@linkplain EStructuralFeature#isChangeable() changeable}.
*
* @param eObj an EObject
* @return an iterator over its {@link EReference}s that are changeable
*/
private EContentsEList.FeatureIterator getOptimizedCrossReferenceIterator(
EObject eObj) {
List features = getCrossReferencesChangeableFeatures(eObj.eClass());
if (features != null) {
EContentsEList list = null;
if (features.size() > 0) {
list = new ECrossReferenceEList(eObj,
(EStructuralFeature[]) features
.toArray(new EStructuralFeature[features.size()])) {
// to get to the protected constructor
};
} else {
list = ECrossReferenceEList.EMPTY_CROSS_REFERENCE_ELIST;
}
return (EContentsEList.FeatureIterator) (resolve() ? list
.iterator()
: ((InternalEList) list).basicIterator());
}
return (EContentsEList.FeatureIterator) ECrossReferenceEList.EMPTY_CROSS_REFERENCE_ELIST
.iterator();
}
/**
* Like the {@link #getInverseReferences(EObject, boolean)} method,
* obtains settings implementing references to the specified object,
* except that it only considers references that are
* {@linkplain EStructuralFeature#isChangeable() changeable} and can
* {@linkplain EReference#isResolveProxies() reference other resources}.
*
* @param eObject the referenced EObject
* @param resolve whether to resolve proxies or not
*
* @return a collection of {@link EStructuralFeature.Setting}s on
* potentially cross-resource references
*/
public Collection getInverseReferencesCrossResource(EObject eObject, boolean resolve) {
Collection result = new ArrayList();
if (resolve) {
resolveAll(eObject);
}
EObject eContainer = eObject.eContainer();
if (eContainer != null) {
result.add(((InternalEObject) eContainer).eSetting(eObject
.eContainmentFeature()));
}
Collection nonNavigableInverseReferences = (Collection) inverseCrossReferencer
.get(eObject);
if (nonNavigableInverseReferences != null) {
result.addAll(nonNavigableInverseReferences);
}
for (Iterator i = eObject.eClass().getEAllReferences().iterator(); i
.hasNext();) {
EReference eReference = (EReference) i.next();
EReference eOpposite = eReference.getEOpposite();
if (eOpposite != null
&& isImportExportCapable(eReference, eObject)
&& eObject.eIsSet(eReference)) {
if (FeatureMapUtil.isMany(eObject, eReference)) {
Object collection = eObject.eGet(eReference);
for (Iterator j = resolve() ? ((Collection) collection)
.iterator() : ((InternalEList) collection)
.basicIterator(); j.hasNext();) {
InternalEObject referencingEObject = (InternalEObject) j
.next();
result.add(referencingEObject.eSetting(eOpposite));
}
} else {
// although the reference is set, the value could be null
InternalEObject referencingEObject = ((InternalEObject) eObject
.eGet(eReference, resolve()));
if (referencingEObject != null) {
result.add(referencingEObject.eSetting(eOpposite));
}
}
}
}
return result;
}
/**
* Queries whether the specified reference, applied to the given owner
* object, is capable of establishing a resource import or export by
* virtue of being a mutable cross-resource reference.
* <p>
* A reference is considered to support resource imports and exports if
* all of the following apply:
* </p>
* <ul>
* <li>the reference is not a container or containment reference. Note
* that this excludes cross-resource containment from registering
* as an import/export dependency</li>
* <li>the reference resolves proxies</li>
* <li>the reference is changeable</li>
* </ul>
*
* @param reference a reference feature
* @param owner an object under consideration that defines this reference.
* Subclasses may need to introspect the object or its EClass to further
* refine their criteria
*
* @return <code>true</code> if this reference in the context of this
* owner should be counted for resource imports and exports;
* false, otherwise
*/
protected boolean isImportExportCapable(EReference reference, EObject owner) {
return !reference.isContainer()
&& !reference.isContainment()
&& reference.isResolveProxies() // can be cross-resource
&& reference.isChangeable(); // not computed
}
}