| /*******************************************************************************
|
| * Copyright (c) 2009, 2019 Mia-Software and others.
|
| * All rights reserved. This program and the accompanying materials
|
| * are made available under the terms of the Eclipse Public License v2.0
|
| * which accompanies this distribution, and is available at
|
| * http://www.eclipse.org/legal/epl-v20.html
|
| *
|
| * Contributors:
|
| * Gregoire DUPE (Mia-Software)
|
| * Nicolas Bros (Mia-Software)
|
| * Grégoire Dupé (Mia-Software) - Bug 471096 - MetaclassInstance features have to be moved to an EMF dedicated plug-in
|
| *******************************************************************************/ |
| package org.eclipse.modisco.infra.facet.core;
|
|
|
| import java.util.ArrayList;
|
| import java.util.Collection;
|
| import java.util.HashSet;
|
| import java.util.List;
|
| import java.util.Set;
|
|
|
| import org.eclipse.core.runtime.IStatus;
|
| import org.eclipse.core.runtime.Status;
|
| import org.eclipse.emf.common.util.BasicEList;
|
| import org.eclipse.emf.common.util.EList;
|
| import org.eclipse.emf.common.util.TreeIterator;
|
| import org.eclipse.emf.ecore.EAttribute;
|
| 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.Resource;
|
| import org.eclipse.emf.ecore.util.EcoreUtil;
|
| import org.eclipse.modisco.infra.common.core.logging.MoDiscoLogger;
|
| import org.eclipse.modisco.infra.facet.Facet;
|
| import org.eclipse.modisco.infra.facet.FacetAttribute;
|
| import org.eclipse.modisco.infra.facet.FacetReference;
|
| import org.eclipse.modisco.infra.facet.FacetSet;
|
| import org.eclipse.modisco.infra.facet.FacetStructuralFeature;
|
| import org.eclipse.modisco.infra.facet.Shortcut;
|
| import org.eclipse.modisco.infra.facet.core.adapters.instances.MetaclassInstancesAdapterFactoryWithFacet;
|
| import org.eclipse.modisco.infra.facet.core.exception.ModiscoFacetException;
|
| import org.eclipse.modisco.infra.facet.core.exception.StructuralConstraintViolationException;
|
| import org.eclipse.modisco.infra.facet.core.internal.Activator;
|
| import org.eclipse.modisco.infra.query.ModelQuery;
|
| import org.eclipse.modisco.infra.query.core.AbstractModelQuery;
|
| import org.eclipse.modisco.infra.query.core.ModelQuerySetCatalog;
|
| import org.eclipse.modisco.infra.query.core.exception.ModelQueryException;
|
| import org.eclipse.modisco.util.emf.core.internal.allinstances.MetaclassInstances;
|
|
|
| /**
|
| * @author Gregoire DUPE
|
| * @deprecated Replaced by EMF Facet
|
| */
|
| @Deprecated
|
| public class FacetContext {
|
|
|
| private final Set<Facet> appliedFacets = new HashSet<Facet>();
|
| private final List<EStructuralFeature> appliedFeatures = new ArrayList<EStructuralFeature>();
|
| private final Set<Resource> resources = new HashSet<Resource>();
|
| private final List<FacetContextListener> fListeners = new ArrayList<FacetContextListener>();
|
|
|
| /**
|
| * @param resources
|
| * the resources that will be used to resolve {@link Shortcut}s
|
| */
|
| public void setResources(final Collection<Resource> resources) {
|
| synchronized (this.resources) {
|
| this.resources.clear();
|
| }
|
| for (Resource resource : resources) {
|
| addComposedResource(resource);
|
| }
|
| }
|
|
|
| private void addComposedResource(final Resource resource) {
|
| if (resource == null) {
|
| return;
|
| }
|
| synchronized (this.resources) {
|
| this.resources.add(resource);
|
| }
|
| synchronized (resource) {
|
| TreeIterator<EObject> allContents = EcoreUtil.getAllContents(resource, false);
|
| while (allContents.hasNext()) {
|
| EObject element = allContents.next();
|
| if (element.eResource() != resource) {
|
| synchronized (this.resources) {
|
| this.resources.add(element.eResource());
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| public void addFacetSet(final FacetSet facetSet) {
|
| // this.appliedFacetSet.add(facetSet);
|
| for (Facet facet : facetSet.getFacets()) {
|
| addFacet(facet);
|
| }
|
| }
|
|
|
| public void addFacet(final Facet facet) {
|
| boolean contained;
|
| synchronized (this.appliedFacets) {
|
| contained = this.appliedFacets.contains(facet);
|
| if (!contained) {
|
| this.appliedFacets.add(facet);
|
| }
|
| }
|
| if (!contained) {
|
| notifyFacetAdded(facet);
|
| for (EStructuralFeature feature : facet.getEStructuralFeatures()) {
|
| if (feature instanceof FacetStructuralFeature || feature instanceof Shortcut) {
|
| synchronized (this.appliedFeatures) {
|
| this.appliedFeatures.add(feature);
|
| }
|
| }
|
| }
|
| }
|
| }
|
|
|
| public boolean isInstance(final EObject eObject, final Facet facet) throws ModelQueryException {
|
| ModelQuery modelQuery = facet.getConditionQuery();
|
| boolean result = false;
|
| boolean isSuperType = false;
|
| for (EClass superType : facet.getESuperTypes()) {
|
| if (superType.isSuperTypeOf(eObject.eClass())) {
|
| isSuperType = true;
|
| break;
|
| }
|
| }
|
| if (isSuperType) {
|
| if (modelQuery == null) {
|
| result = true;
|
| } else {
|
| AbstractModelQuery abstractModelQuery = ModelQuerySetCatalog.getSingleton()
|
| .getModelQueryImpl(modelQuery);
|
| try {
|
| Object queryResult = abstractModelQuery.basicEvaluate(eObject);
|
| if (queryResult instanceof Boolean) {
|
| result = ((Boolean) queryResult).booleanValue();
|
| } else {
|
| String message = "Query " + abstractModelQuery.toString() //$NON-NLS-1$
|
| + " didn't return a boolean result as expected."; //$NON-NLS-1$
|
| MoDiscoLogger.logError(message, Activator.getDefault());
|
| }
|
| } catch (ModelQueryException e) {
|
| result = false;
|
| throw e;
|
| } catch (Exception e) {
|
| result = false;
|
| MoDiscoLogger.logError(e, Activator.getDefault());
|
| throw new ModelQueryException("FacetContext failed to execute a query", e); //$NON-NLS-1$
|
| }
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public Object get(final EObject eObject, final EStructuralFeature structuralFeature)
|
| throws ModelQueryException, ModiscoFacetException {
|
| if (structuralFeature == null) {
|
| throw new ModiscoFacetException("The parameter named structuralFeature is null"); //$NON-NLS-1$
|
| }
|
| Object result = null;
|
| boolean contained;
|
| synchronized (this.appliedFeatures) {
|
| contained = this.appliedFeatures.contains(structuralFeature);
|
| }
|
| if (contained) {
|
| Facet facet = (Facet) structuralFeature.eContainer();
|
| if (isInstance(eObject, facet)) {
|
| if (structuralFeature instanceof FacetStructuralFeature) {
|
| FacetStructuralFeature facetStructuralFeature = (FacetStructuralFeature) structuralFeature;
|
| ModelQuery modelQuery = facetStructuralFeature.getValueQuery();
|
| AbstractModelQuery abstractModelQuery = ModelQuerySetCatalog.getSingleton()
|
| .getModelQueryImpl(modelQuery);
|
| result = abstractModelQuery.basicEvaluate(eObject);
|
| } else if (structuralFeature instanceof Shortcut) {
|
| Shortcut shortcut = (Shortcut) structuralFeature;
|
| List<EObject> resultList = new BasicEList<EObject>();
|
| EReference oppositeRef = shortcut.getOppositeReference();
|
| EClass eClass = oppositeRef.getEContainingClass();
|
| List<EObject> list = allInstances(eClass);
|
| for (EObject modelElement : list) {
|
| EObject referedByModelElement = (EObject) modelElement.eGet(oppositeRef);
|
| if (referedByModelElement == eObject) {
|
| EObject element = modelElement;
|
| for (EReference eReference : shortcut.getPath()) {
|
| element = (EObject) element.eGet(eReference);
|
| }
|
| resultList.add(element);
|
| }
|
| }
|
| if (shortcut.getUpperBound() > 1) {
|
| result = resultList;
|
| } else {
|
| if (resultList.size() > 1) {
|
| throw new StructuralConstraintViolationException();
|
| } else if (resultList.size() == 1) {
|
| result = resultList.get(0);
|
| }
|
| // else result = null;
|
| }
|
| } else {
|
| throw new ModiscoFacetException(
|
| "The structuralFeature parameter must be a FacetStructuralFeature: " //$NON-NLS-1$
|
| + structuralFeature.toString());
|
| }
|
| } else {
|
| throw new ModiscoFacetException("The eObject parameter must be an instance of : " //$NON-NLS-1$
|
| + facet.getName());
|
| }
|
| } else {
|
| throw new ModiscoFacetException(
|
| "The structuralFeature must be registered into the context, please use the " //$NON-NLS-1$
|
| + FacetContext.class.getSimpleName() + ".add(FacetSet) method."); //$NON-NLS-1$
|
| }
|
|
|
| if (result instanceof Collection<?> && !(result instanceof BasicEList<?>)) {
|
| Collection<?> list = (Collection<?>) result;
|
| @SuppressWarnings("unchecked")
|
| BasicEList basicEList = new BasicEList(list);
|
| result = basicEList;
|
| }
|
| return result;
|
| }
|
|
|
| protected List<EObject> allInstances(final EClass eClass) {
|
| List<EObject> result = new ArrayList<EObject>();
|
| MetaclassInstancesAdapterFactoryWithFacet.getInstance().setFacetContext(this);
|
| synchronized (this.resources) {
|
| for (Resource resource : this.resources) {
|
| MetaclassInstances instances = (MetaclassInstances) MetaclassInstancesAdapterFactoryWithFacet
|
| .getInstance().adapt(resource, MetaclassInstances.class);
|
| result.addAll(instances.getInstances(eClass, true));
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public List<EStructuralFeature> getFacetFeatures(final EObject eObject) {
|
| List<EStructuralFeature> result = new ArrayList<EStructuralFeature>();
|
| for (Facet facet : getAppliedFacets()) {
|
| try {
|
| if (isInstance(eObject, facet)) {
|
| result.addAll(facet.getEStructuralFeatures());
|
| }
|
| } catch (ModelQueryException e) {
|
| IStatus status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e);
|
| Activator.getDefault().getLog().log(status);
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public void addAll(final Collection<FacetSet> allFacetSets) {
|
| for (FacetSet facetSet : allFacetSets) {
|
| addFacetSet(facetSet);
|
| }
|
| }
|
|
|
| public EList<EAttribute> getAttributes(final EObject eObject) throws ModelQueryException {
|
| EList<EAttribute> result = new BasicEList<EAttribute>();
|
| for (Facet facet : getAppliedFacets()) {
|
| if (isInstance(eObject, facet)) {
|
| for (EStructuralFeature structuralFeature : facet.getEStructuralFeatures()) {
|
| if (structuralFeature instanceof FacetAttribute) {
|
| FacetAttribute facetAttribute = (FacetAttribute) structuralFeature;
|
| result.add(facetAttribute);
|
| }
|
| }
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public EList<EReference> getReferences(final EObject eObject) throws ModelQueryException {
|
| EList<EReference> result = new BasicEList<EReference>();
|
| for (Facet facet : getAppliedFacets()) {
|
| if (isInstance(eObject, facet)) {
|
| for (EStructuralFeature structuralFeature : facet.getEStructuralFeatures()) {
|
| if (structuralFeature instanceof FacetReference
|
| || structuralFeature instanceof Shortcut) {
|
| EReference facetAttribute = (EReference) structuralFeature;
|
| result.add(facetAttribute);
|
| }
|
| }
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public List<EClass> getMetaClasses() {
|
| List<EClass> metaClasses = new ArrayList<EClass>();
|
| synchronized (this.appliedFacets) {
|
| metaClasses.addAll(this.appliedFacets);
|
| }
|
| return metaClasses;
|
| }
|
|
|
| public List<Facet> getFacets(final EObject eObject) {
|
| List<Facet> result = new ArrayList<Facet>();
|
| for (Facet facet : getAppliedFacets()) {
|
| try {
|
| if (isInstance(eObject, facet)) {
|
| result.add(facet);
|
| }
|
| } catch (ModelQueryException e) {
|
| MoDiscoLogger.logError(e, Activator.getDefault());
|
| }
|
| }
|
| return result;
|
| }
|
|
|
| public Collection<Facet> getAppliedFacets() {
|
| return new ArrayList<Facet>(this.appliedFacets);
|
| }
|
|
|
| public void clear() {
|
| synchronized (this.appliedFeatures) {
|
| this.appliedFeatures.clear();
|
| }
|
| synchronized (this.appliedFacets) {
|
| this.appliedFacets.clear();
|
| }
|
| notifyFacetsCleared();
|
| }
|
|
|
| protected Collection<EStructuralFeature> getAppliedFeatures() {
|
| return new ArrayList<EStructuralFeature>(this.appliedFeatures);
|
| }
|
|
|
| public void addListener(final FacetContextListener listener) {
|
| synchronized (this.fListeners) {
|
| if (!this.fListeners.contains(listener)) {
|
| this.fListeners.add(listener);
|
| }
|
| }
|
| }
|
|
|
| public synchronized void removeListener(final FacetContextListener listener) {
|
| synchronized (this.fListeners) {
|
| this.fListeners.remove(listener);
|
| }
|
| }
|
|
|
| public void notifyFacetAdded(final Facet facet) {
|
| // copy list to allow clients to modify the listener list
|
| List<FacetContextListener> listeners = new ArrayList<FacetContextListener>(this.fListeners);
|
| for (FacetContextListener listener : listeners) {
|
| listener.facetAdded(facet);
|
| }
|
| }
|
|
|
| public void notifyFacetsCleared() {
|
| // copy list to allow clients to modify the listener list
|
| List<FacetContextListener> listeners = new ArrayList<FacetContextListener>(this.fListeners);
|
| for (FacetContextListener listener : listeners) {
|
| listener.facetsCleared();
|
| }
|
| }
|
| }
|
