/** * Returns a list that holds the opposite elements of the given reference for the given owner. The * opposite elements are those of type E that have the reference to owner. * * <p>The collection corresponding to opposite in the following picture is returned, for given * owner and reference. * * <pre> * <b>opposite</b> reference * E ----------------------------- owner * </pre> * * reference has to be a key of the map observedRefToOpposite. * * @param <E> * @param <E> The type of the elements in the collection. * @param dataClass The class of the elements in the collection. * @param owner The object whose list is retrieved. * @param reference The reference whose opposite reference is retrieved. * @return The opposite of reference for owner. */ public <E> List<E> getOppositeList( Class<E> dataClass, InternalEObject owner, EReference reference) { EReference opposite = observedRefToOpposite.get(reference); if (opposite == null) throw new IllegalArgumentException( "This reference is not observed by this adapter: " + reference.toString()); EObjectEList<E> result = new EObjectEList<E>(dataClass, owner, opposite.getFeatureID()); for (Setting cur : getNonNavigableInverseReferences(owner, false)) { if (cur.getEStructuralFeature().equals(reference)) result.add(dataClass.cast(cur.getEObject())); } return result; }
private void adjustTransientOppositeReference( InternalEObject instance, InternalEObject object, EReference oppositeReference) { boolean wasDeliver = object.eDeliver(); // Disable notifications if (wasDeliver) { object.eSetDeliver(false); } try { if (oppositeReference.isMany()) { @SuppressWarnings("unchecked") InternalEList<Object> list = (InternalEList<Object>) object.eGet(oppositeReference); list.basicAdd(instance, null); } else { if (object.eGet(oppositeReference) != instance) { object.eInverseAdd( instance, oppositeReference.getFeatureID(), ((EObject) instance).getClass(), null); } } } finally { if (wasDeliver) { object.eSetDeliver(true); } } }