/*
* Copyright (c) 2006, 2007 Borland Software Corp
*
* 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:
* vano - initial API and implementation
*/
package org.eclipse.gmf.mappings.presentation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.eclipse.emf.common.notify.AdapterFactory;
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.resource.ResourceSet;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.emf.edit.provider.IItemLabelProvider;
import org.eclipse.gmf.mappings.CanvasMapping;
import org.eclipse.gmf.mappings.ChildReference;
import org.eclipse.gmf.mappings.CompartmentMapping;
import org.eclipse.gmf.mappings.FeatureInitializer;
import org.eclipse.gmf.mappings.FeatureSeqInitializer;
import org.eclipse.gmf.mappings.LinkMapping;
import org.eclipse.gmf.mappings.Mapping;
import org.eclipse.gmf.mappings.MappingEntry;
import org.eclipse.gmf.mappings.NodeMapping;
import org.eclipse.gmf.mappings.NodeReference;
import org.eclipse.gmf.mappings.TopNodeReference;
public class FilterUtil {
public static <T> List<T> sort(Collection<T> eObjects) {
ArrayList<T> result = new ArrayList<T>(eObjects);
Collections.sort(result, new EObjectsComparator());
return result;
}
public static <T extends EObject> List<T> filterByResourceSet(Collection<T> eClasses, ResourceSet resourceSet) {
return sort(filterValidEObjectsFrom(eClasses, resourceSet));
}
public static List<EClass> filterByContainmentFeature(Collection<EClass> eClasses, MappingEntry mappingEntry) {
EClass superType = null;
if (mappingEntry instanceof NodeMapping) {
NodeReference nodeReference = (NodeReference) mappingEntry.eContainer();
if (nodeReference != null) {
EReference modelReference = nodeReference.getChildrenFeature() != null ? nodeReference.getChildrenFeature() : nodeReference.getContainmentFeature();
if (modelReference != null) {
superType = modelReference.getEReferenceType();
}
}
} else if (mappingEntry instanceof LinkMapping) {
if (((LinkMapping) mappingEntry).getContainmentFeature() != null) {
superType = ((LinkMapping) mappingEntry).getContainmentFeature().getEReferenceType();
}
}
return sort(getConcreteEClasses(getSubtypesOf(filterValidEObjectsFrom(eClasses, mappingEntry.eResource().getResourceSet()), superType)));
}
public static List<EStructuralFeature> filterByContainerMetaclass(Collection<EStructuralFeature> eReferences, MappingEntry mappingEntry) {
EClass containerMetaClass = mappingEntry.getDomainMetaElement();
return sort(getEStructuralFeaturesOf(eReferences, containerMetaClass));
}
public static List<EReference> filterByContainerMetaclass(Collection<EReference> eReferences, NodeReference nodeReference, boolean containmentOnly) {
EClass containerMetaClass = null;
EClass targetMetaClass = null;
if (nodeReference instanceof ChildReference) {
containerMetaClass = ((ChildReference) nodeReference).getParentNode().getDomainMetaElement();
} else if (nodeReference instanceof TopNodeReference) {
CanvasMapping diagram = ((Mapping) nodeReference.eContainer()).getDiagram();
if (diagram != null) {
containerMetaClass = diagram.getDomainMetaElement();
}
}
if (nodeReference.isSetChild()) {
targetMetaClass = nodeReference.getChild().getDomainMetaElement();
}
List<EReference> fromHierarchy = sort(getEReferences(getEStructuralFeaturesOf(eReferences, containerMetaClass), containmentOnly));
if (targetMetaClass == null) {
// no child known, thus can take references from metaelement's hierarchy only
return fromHierarchy;
}
List<EReference> targetsToChild = sort(getEReferences(getEReferencesOfType(eReferences, targetMetaClass), containmentOnly));
for (Iterator<EReference> it = targetsToChild.iterator(); it.hasNext();) {
if (fromHierarchy.contains(it.next())) {
it.remove();
}
}
ArrayList<EReference> rv = new ArrayList<EReference>(fromHierarchy.size() + targetsToChild.size());
rv.addAll(fromHierarchy);
rv.addAll(targetsToChild);
return rv;
}
public static List<EReference> filterByReferenceType(Collection<EReference> eReferences, LinkMapping linkMapping) {
EClass referenceType = linkMapping.getDomainMetaElement();
return sort(getEReferences(getEReferencesOfType(eReferences, referenceType), true));
}
public static Collection<EObject> filterByNodeMapping(Collection<EObject> childReferences, CompartmentMapping mapping) {
return sort(getChildrenOf(childReferences, mapping.getParentNode(), false));
}
public static Collection<EObject> filterByNodeMapping(Collection<EObject> compartments, ChildReference childReference) {
return getChildrenOf(compartments, childReference.getParentNode(), true);
}
public static Collection<?> filterBySuperClasses(Collection<?> instances, Class<?>[] classes) {
return sort(getSubClassesOf(instances, classes));
}
public static Collection<EStructuralFeature> filterByFeatureInitializer(Collection<EStructuralFeature> features, FeatureInitializer featureInitializer) {
if(featureInitializer.getFeatureSeqInitializer() == null ||
featureInitializer.getFeatureSeqInitializer().getElementClass() == null) {
return features;
}
EClass eClass = featureInitializer.getFeatureSeqInitializer().getElementClass();
List<EStructuralFeature> result = new ArrayList<EStructuralFeature>(getEStructuralFeaturesOf(features, eClass));
for (Iterator<EStructuralFeature> it = result.iterator(); it.hasNext();) {
EStructuralFeature nextFeature = it.next();
if(nextFeature == null || !nextFeature.isChangeable()) {
it.remove();
}
}
return result;
}
public static Collection<EClass> filterByFeatureSeqInitializer(Collection<EClass> eClasses, FeatureSeqInitializer featureSeqInitializer) {
if(featureSeqInitializer.getCreatingInitializer() != null) {
EStructuralFeature feature = featureSeqInitializer.getCreatingInitializer().getFeature();
if(feature != null && feature.getEType() instanceof EClass) {
for (Iterator<EClass> it = eClasses.iterator(); it.hasNext();) {
EClass nextEClass = it.next();
EClass typeEClass = (EClass)feature.getEType();
if(nextEClass == null || nextEClass.isAbstract() || nextEClass.isInterface() || !typeEClass.isSuperTypeOf(nextEClass)) {
it.remove();
}
}
}
} else if(featureSeqInitializer.getElementClass() != null) {
return Collections.singleton(featureSeqInitializer.getElementClass());
}
return eClasses;
}
public static Collection<EClass> getSubtypesOf(Collection<EClass> eClasses, EClass superType) {
if (superType == null) {
return eClasses;
}
for (Iterator<EClass> it = eClasses.iterator(); it.hasNext();) {
EClass nextEClass = it.next();
if (nextEClass != null && !superType.isSuperTypeOf(nextEClass)) {
it.remove();
}
}
return eClasses;
}
public static Collection<EClass> getConcreteEClasses(Collection<EClass> eClasses) {
for (Iterator<EClass> it = eClasses.iterator(); it.hasNext();) {
EClass nextEClass = it.next();
if (nextEClass != null && (nextEClass.isAbstract() || nextEClass.isInterface())) {
it.remove();
}
}
return eClasses;
}
public static Collection<EReference> getEReferences(Collection<EReference> eReferences, boolean containmentOnly) {
if (!containmentOnly) {
return eReferences;
}
for (Iterator<EReference> it = eReferences.iterator(); it.hasNext();) {
EReference nextReference = it.next();
if (nextReference != null && !nextReference.isContainment()) {
it.remove();
}
}
return eReferences;
}
public static <T extends EStructuralFeature> Collection<T> getEStructuralFeaturesOf(Collection<T> structuralFeatures, EClass featureContainerEClass) {
Collection<T> result = getValidEStructuralFeatures(structuralFeatures);
if (featureContainerEClass == null) {
return result;
}
for (Iterator<T> it = result.iterator(); it.hasNext();) {
EStructuralFeature nextFeature = it.next();
if (nextFeature != null && !nextFeature.getEContainingClass().isSuperTypeOf(featureContainerEClass)) {
it.remove();
}
}
return result;
}
public static Collection<EReference> getEReferencesOfType(Collection<EReference> references, EClass referenceType) {
Collection<EReference> result = getValidEStructuralFeatures(references);
if (referenceType == null) {
return result;
}
for (Iterator<EReference> it = result.iterator(); it.hasNext();) {
EReference nextFeature = it.next();
if (nextFeature != null && !nextFeature.getEReferenceType().isSuperTypeOf(referenceType)) {
it.remove();
}
}
return result;
}
public static <T extends EStructuralFeature> Collection<T> getValidEStructuralFeatures(Collection<T> structuralFeatures) {
Collection<T> result = getValidEObjects(structuralFeatures);
for (Iterator<T> it = result.iterator(); it.hasNext();) {
EStructuralFeature nextFeature = it.next();
if (nextFeature != null && (nextFeature.getEContainingClass() == null)) {
it.remove();
}
}
return result;
}
public static <T extends EObject> Collection<T> filterValidEObjectsFrom(Collection<T> eClasses, ResourceSet resourceSet) {
Collection<T> result = getValidEObjects(eClasses);
for (Iterator<T> it = result.iterator(); it.hasNext();) {
EObject nextEClass = it.next();
if (nextEClass == null) {
continue;
}
if (nextEClass.eResource().getResourceSet() != resourceSet) {
it.remove();
}
}
return result;
}
public static <T extends EObject> Collection<T> getValidEObjects(Collection<T> eObjects) {
LinkedList<T> result = new LinkedList<T>();
for (T nextEObject : eObjects) {
if (nextEObject != null && (nextEObject.eContainer() == null)) {
continue;
}
result.add(nextEObject);
}
return result;
}
public static <T extends EObject> Collection<T> getChildrenOf(Collection<T> elements, EObject container, boolean addNull) {
LinkedList<T> result = new LinkedList<T>();
for (T nextEObject : elements) {
if (nextEObject == null ? addNull : nextEObject.eContainer() == container) {
result.add(nextEObject);
}
}
return result;
}
public static Collection<?> getSubClassesOf(Collection<?> instances, Class<?>[] classes) {
LinkedList<Object> result = new LinkedList<Object>();
for (Object nextInstance : instances) {
for (int i = 0; i < classes.length; i++) {
if (nextInstance == null || classes[i].isAssignableFrom(nextInstance.getClass())) {
result.add(nextInstance);
break;
}
}
}
return result;
}
private static class EObjectsComparator implements Comparator<Object> {
public int compare(Object o1, Object o2) {
if (o1 instanceof EObject && o2 instanceof EObject) {
EObject firstEObject = (EObject) o1;
EObject secondEObject = (EObject) o2;
return compareLabels(firstEObject, secondEObject);
}
return compareObjects(o1, o2);
}
private int compareObjects(Object o1, Object o2) {
if (o1 == null) {
return o2 == null ? 0 : 1;
} else {
return o2 == null ? -1 : 0;
}
}
private int compareLabels(EObject firstEObject, EObject secondEObject) {
String firstLabel = getLabel(firstEObject);
String secondLabel = getLabel(secondEObject);
return firstLabel == null ? (secondLabel == null ? 0 : 1) : (secondLabel == null ? -1 : firstLabel.compareTo(secondLabel));
}
private String getLabel(EObject eObject) {
AdapterFactory adapterFactory = getAdapterFactory(eObject);
if (adapterFactory == null) {
return "";
}
IItemLabelProvider itemLabelProvider = (IItemLabelProvider) adapterFactory.adapt(eObject, IItemLabelProvider.class);
return itemLabelProvider != null ? itemLabelProvider.getText(eObject) : eObject == null ? "" : eObject.toString();
}
private AdapterFactory getAdapterFactory(EObject eObject) {
EditingDomain editingDomain = AdapterFactoryEditingDomain.getEditingDomainFor(eObject);
if (editingDomain instanceof AdapterFactoryEditingDomain) {
return ((AdapterFactoryEditingDomain) editingDomain).getAdapterFactory();
}
return null;
}
}
}
