/**
* Copyright (c) 2010 Henning Heitkoetter.
* 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:
* Henning Heitkoetter - initial API and implementation
*/
package org.eclipse.bpmn2.util;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.eclipse.bpmn2.Bpmn2Package;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature.Setting;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.util.BasicInternalEList;
import org.eclipse.emf.ecore.util.ECrossReferenceAdapter;
import org.eclipse.emf.ecore.util.EObjectEList;
/**
* A cross reference adapter for resolving virtual opposite references.
*
* It observes a set of references and is able to construct opposite references for these references.
* @author Henning Heitkoetter
*
*/
public class Bpmn2OppositeReferenceAdapter extends ECrossReferenceAdapter {
public static final Map<EReference, EReference> DEFAULT_OBSERVED_REFERENCES;
static {
DEFAULT_OBSERVED_REFERENCES = new HashMap<EReference, EReference>();
DEFAULT_OBSERVED_REFERENCES.put(Bpmn2Package.Literals.FLOW_ELEMENT__CATEGORY_VALUE_REF,
Bpmn2Package.Literals.CATEGORY_VALUE__CATEGORIZED_FLOW_ELEMENTS);
DEFAULT_OBSERVED_REFERENCES.put(Bpmn2Package.Literals.CONVERSATION_LINK__SOURCE_REF,
Bpmn2Package.Literals.INTERACTION_NODE__OUTGOING_CONVERSATION_LINKS);
DEFAULT_OBSERVED_REFERENCES.put(Bpmn2Package.Literals.CONVERSATION_LINK__TARGET_REF,
Bpmn2Package.Literals.INTERACTION_NODE__INCOMING_CONVERSATION_LINKS);
}
/**
* A map from references that will be observed by this adapter to their (virtual) opposite reference.
*/
protected Map<EReference, EReference> observedRefToOpposite = new HashMap<EReference, EReference>();
public Bpmn2OppositeReferenceAdapter(Map<EReference, EReference> observedRefToOpposite) {
super();
this.observedRefToOpposite.putAll(observedRefToOpposite);
}
public Bpmn2OppositeReferenceAdapter() {
this(DEFAULT_OBSERVED_REFERENCES);
}
public EReference putObservedRefToOpposite(EReference key, EReference value) {
return observedRefToOpposite.put(key, value);
}
public EReference removeObservedRef(Object key) {
return observedRefToOpposite.remove(key);
}
/**
* Returns true if the reference is being watched by this adapter.
*/
@Override
protected boolean isIncluded(EReference eReference) {
return observedRefToOpposite.containsKey(eReference);
}
/**
* 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.
*
* 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());
List<E> result = new BasicInternalEList<E>(dataClass);
for (Setting cur : getNonNavigableInverseReferences(owner, false)) {
if (cur.getEStructuralFeature().equals(reference))
result.add(dataClass.cast(cur.getEObject()));
}
return result;
}
}