1 files changed, 356 insertions, 0 deletions

diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFModelComprehension.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFModelComprehension.java
new file mode 100644
index 00000000..bde93367
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFModelComprehension.java
@@ -0,0 +1,356 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2010 Gabor Bergmann and Daniel Varro
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-v20.html.
+ * 
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+
+package tools.refinery.viatra.runtime.base.comprehension;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EcorePackage;
+import org.eclipse.emf.ecore.InternalEObject;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.util.ExtendedMetaData;
+import org.eclipse.emf.ecore.util.FeatureMap;
+import org.eclipse.emf.ecore.util.FeatureMap.Entry;
+import org.eclipse.emf.ecore.util.InternalEList;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexFeatureFilter;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexObjectFilter;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexResourceFilter;
+
+/**
+ * @author Bergmann Gábor
+ * 
+ *         Does not directly visit derived links, unless marked as a WellBehavingFeature. Derived edges are
+ *         automatically interpreted correctly in these cases: - EFeatureMaps - eOpposites of containments
+ * 
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class EMFModelComprehension {
+
+    /**
+     * @since 2.3
+     */
+    protected BaseIndexOptions options;
+    
+    /**
+     * Creates a model comprehension with the specified options. The options are copied, therefore subsequent changes
+     * will not affect the comprehension.
+     */
+    public EMFModelComprehension(BaseIndexOptions options) {
+        this.options = options.copy();
+    }
+    
+    /**
+     * Should not traverse this feature directly. It is still possible that it can be represented in IQBase if
+     * {@link #representable(EStructuralFeature)} is true.
+     */
+    public boolean untraversableDirectly(EStructuralFeature feature) {
+
+    if((feature instanceof EReference && ((EReference)feature).isContainer())) {
+            // container features are always represented through their opposite
+            return true;
+        }
+
+    //If the feature is filtered by the feature filter specified in the BaseIndexOptions, return true
+        final IBaseIndexFeatureFilter featureFilter = options.getFeatureFilterConfiguration();
+        if(featureFilter != null && featureFilter.isFiltered(feature)){
+            return true;
+        }
+
+        boolean suspect = onlySamplingFeature(feature);
+        if(suspect) {
+            // even if the feature can only be sampled, it may be used if the proper base index option is set
+            suspect = options.isTraverseOnlyWellBehavingDerivedFeatures();
+        }
+        return suspect;
+    }
+
+    /**
+     * Decides whether a feature can only be sampled as there is no guarantee that proper notifications will be
+     * delivered by their implementation.
+     * 
+     * <p/> Such features are derived (and/or volatile) features that are not well-behaving.
+     */
+    public boolean onlySamplingFeature(EStructuralFeature feature) {
+        boolean suspect = 
+                feature.isDerived() || 
+                feature.isVolatile();
+        if (suspect) {
+            // override support here
+            // (e.g. if manual notifications available, or no changes expected afterwards)
+            suspect = !WellbehavingDerivedFeatureRegistry.isWellbehavingFeature(feature);
+            // TODO verbose flag somewhere to ease debugging (for such warnings)
+            // TODO add warning about not visited subtree (containment, FeatureMap and annotation didn't define
+            // otherwise)
+        }
+        return suspect;
+    }
+
+    /**
+     * This feature can be represented in IQBase.
+     */
+    public boolean representable(EStructuralFeature feature) {
+        if (!untraversableDirectly(feature))
+            return true;
+
+        if (feature instanceof EReference) {
+            final EReference reference = (EReference) feature;
+            if (reference.isContainer() && representable(reference.getEOpposite()))
+                return true;
+        }
+
+        boolean isMixed = "mixed".equals(EcoreUtil.getAnnotation(feature.getEContainingClass(),
+                ExtendedMetaData.ANNOTATION_URI, "kind"));
+        if (isMixed)
+            return true; // TODO maybe check the "name"=":mixed" or ":group" feature for representability?
+
+        // Group features are alternative features that are used when the ecore is derived from an xsd schema containing
+        // choices; in that case instead of the asked feature we should index the corresponding group feature
+        final EStructuralFeature groupFeature = ExtendedMetaData.INSTANCE.getGroup(feature);
+        if (groupFeature != null) {
+            return representable(groupFeature);
+        }
+
+        return false;
+    }
+
+    /** 
+     * Resource filters not consulted here (for performance), because model roots are assumed to be pre-filtered. 
+     */
+    public void traverseModel(EMFVisitor visitor, Notifier source) {
+        if (source == null)
+            return;
+        if (source instanceof EObject) {
+            final EObject sourceObject = (EObject) source;
+            if (sourceObject.eIsProxy()) 
+                throw new IllegalArgumentException("Proxy EObject cannot act as model roots for VIATRA: " + source);
+            traverseObject(visitor, sourceObject);
+        } else if (source instanceof Resource) {
+            traverseResource(visitor, (Resource) source);
+        } else if (source instanceof ResourceSet) {
+            traverseResourceSet(visitor, (ResourceSet) source);
+        }
+    }
+
+    public void traverseResourceSet(EMFVisitor visitor, ResourceSet source) {
+        if (source == null)
+            return;
+        final List<Resource> resources = new ArrayList<Resource>(source.getResources());
+        for (Resource resource : resources) {
+            traverseResourceIfUnfiltered(visitor, resource);
+        }
+    }
+
+    public void traverseResourceIfUnfiltered(EMFVisitor visitor, Resource resource) {
+        final IBaseIndexResourceFilter resourceFilter = options.getResourceFilterConfiguration();
+        if (resourceFilter != null && resourceFilter.isResourceFiltered(resource))
+            return;
+        final IBaseIndexObjectFilter objectFilter = options.getObjectFilterConfiguration();
+        if (objectFilter != null && objectFilter.isFiltered(resource))
+            return;
+        
+        traverseResource(visitor, resource);
+    }
+
+    public void traverseResource(EMFVisitor visitor, Resource source) {
+        if (source == null)
+            return;
+        if (visitor.pruneSubtrees(source))
+            return;
+        final EList<EObject> contents = source.getContents();
+        for (EObject eObject : contents) {
+            traverseObjectIfUnfiltered(visitor, eObject);
+        }
+    }
+
+
+    public void traverseObjectIfUnfiltered(EMFVisitor visitor, EObject targetObject) {
+        final IBaseIndexObjectFilter objectFilter = options.getObjectFilterConfiguration();
+        if (objectFilter != null && objectFilter.isFiltered(targetObject))
+            return;
+        
+        traverseObject(visitor, targetObject);
+    }
+
+    public void traverseObject(EMFVisitor visitor, EObject source) {
+        if (source == null)
+            return;
+
+        if (visitor.preOrder()) visitor.visitElement(source);
+        for (EStructuralFeature feature : source.eClass().getEAllStructuralFeatures()) {
+            if (untraversableDirectly(feature))
+                continue;
+            final boolean visitorPrunes = visitor.pruneFeature(feature);
+            if (visitorPrunes && !unprunableFeature(visitor, source, feature))
+                continue;
+
+            traverseFeatureTargets(visitor, source, feature, visitorPrunes);
+        }
+        if (!visitor.preOrder()) visitor.visitElement(source);
+    }
+    
+    protected void traverseFeatureTargets(EMFVisitor visitor, EObject source, EStructuralFeature feature,
+            final boolean visitorPrunes) {
+        boolean attemptResolve = (feature instanceof EAttribute) || visitor.attemptProxyResolutions(source, (EReference)feature);
+        if (feature.isMany()) {
+            EList<?> targets = (EList<?>) source.eGet(feature);
+            int position = 0;
+            Iterator<?> iterator = attemptResolve ? targets.iterator() : ((InternalEList<?>)targets).basicIterator(); 
+            while (iterator.hasNext()) {
+                Object target = iterator.next();
+                traverseFeatureInternal(visitor, source, feature, target, visitorPrunes, position++);                   
+            }
+        } else {
+            Object target = source.eGet(feature, attemptResolve);
+            if (target != null)
+                traverseFeatureInternal(visitor, source, feature, target, visitorPrunes, null);
+        }
+    }
+    /**
+     * @since 2.3
+     */
+    protected boolean unprunableFeature(EMFVisitor visitor, EObject source, EStructuralFeature feature) {
+        return (feature instanceof EAttribute && EcorePackage.eINSTANCE.getEFeatureMapEntry().equals(
+                ((EAttribute) feature).getEAttributeType()))
+                || (feature instanceof EReference && ((EReference) feature).isContainment() && (!visitor
+                        .pruneSubtrees(source) || ((EReference) feature).getEOpposite() != null));
+    }
+
+    /**
+     * @param position optional: known position in multivalued collection (for more efficient proxy resolution)
+     */
+    public void traverseFeature(EMFVisitor visitor, EObject source, EStructuralFeature feature, Object target, Integer position) {
+        if (target == null)
+            return;
+        if (untraversableDirectly(feature))
+            return;
+        traverseFeatureInternalSimple(visitor, source, feature, target, position);
+    }
+
+    /**
+     * @param position optional: known position in multivalued collection (for more efficient proxy resolution)
+     * @since 2.3
+     */
+    protected void traverseFeatureInternalSimple(EMFVisitor visitor, EObject source, EStructuralFeature feature,
+            Object target, Integer position) {
+        final boolean visitorPrunes = visitor.pruneFeature(feature);
+        if (visitorPrunes && !unprunableFeature(visitor, source, feature))
+            return;
+
+        traverseFeatureInternal(visitor, source, feature, target, visitorPrunes, position);
+    }
+
+    /**
+     * @pre target != null
+     * @param position optional: known position in multivalued collection (for more efficient proxy resolution)
+     * @since 2.3
+     */
+    protected void traverseFeatureInternal(EMFVisitor visitor, EObject source, EStructuralFeature feature,
+            Object target, boolean visitorPrunes, Integer position) {
+        if (feature instanceof EAttribute) {
+            if (!visitorPrunes)
+                visitor.visitAttribute(source, (EAttribute) feature, target);
+            if (target instanceof FeatureMap.Entry) { // emulated derived edge based on FeatureMap
+                Entry entry = (FeatureMap.Entry) target;
+                final EStructuralFeature emulated = entry.getEStructuralFeature();
+                final Object emulatedTarget = entry.getValue();
+
+                emulateUntraversableFeature(visitor, source, emulated, emulatedTarget);
+            }
+        } else if (feature instanceof EReference) {
+            EReference reference = (EReference) feature;
+            EObject targetObject = (EObject) target;
+            if (reference.isContainment()) {
+                if (!visitor.avoidTransientContainmentLink(source, reference, targetObject)) {
+                    if (!visitorPrunes)
+                        visitor.visitInternalContainment(source, reference, targetObject);
+                    if (!visitor.pruneSubtrees(source)) {
+                        // Recursively follow containment...
+                        // unless cross-resource containment (in which case we may skip) 
+                        Resource targetResource = (targetObject instanceof InternalEObject)?
+                                ((InternalEObject)targetObject).eDirectResource() : null;
+                        boolean crossResourceContainment = targetResource != null;
+                        if (!crossResourceContainment || visitor.descendAlongCrossResourceContainments()) {
+                            // in-resource containment shall be followed
+                            // as well as cross-resource containment for an object scope
+                            traverseObjectIfUnfiltered(visitor, targetObject);
+                        } else {
+                            // do not follow
+                            // target will be traversed separately from its resource (resourceSet scope)
+                            // or left out of scope (resource scope)
+                        }
+                    }
+                    
+                    final EReference opposite = reference.getEOpposite();
+                    if (opposite != null) { // emulated derived edge based on container opposite
+                        emulateUntraversableFeature(visitor, targetObject, opposite, source);
+                    }                           
+                }
+            } else {
+                // if (containedElements.contains(target))
+                if (!visitorPrunes)
+                    visitor.visitNonContainmentReference(source, reference, targetObject);
+            }
+            if (targetObject.eIsProxy()) {
+                if (!reference.isResolveProxies()) {
+                    throw new IllegalStateException(String.format(
+                            "EReference '%s' of EClass %s is set as proxy-non-resolving (i.e. it should never point to a proxy, and never lead cross-resource), " +
+                                    "yet VIATRA Base encountered a proxy object %s referenced from %s.",
+                                    reference.getName(), reference.getEContainingClass().getInstanceTypeName(),
+                                    targetObject, source));
+                }
+                visitor.visitProxyReference(source, reference, targetObject, position);
+            }
+        }
+
+    }
+
+
+    /**
+     * Emulates a derived edge, if it is not visited otherwise
+     * 
+     * @pre target != null
+     * @since 2.3
+     */
+    protected void emulateUntraversableFeature(EMFVisitor visitor, EObject source,
+            final EStructuralFeature emulated, final Object target) {
+        if (untraversableDirectly(emulated))
+            traverseFeatureInternalSimple(visitor, source, emulated, target, null);
+    }
+
+    /**
+     * Can be called to attempt to resolve a reference pointing to one or more proxies, using eGet().
+     */
+    @SuppressWarnings("unchecked")
+    public void tryResolveReference(EObject source, EReference reference) {
+        final Object result = source.eGet(reference, true);
+        if (reference.isMany()) {
+            // no idea which element to get, have to iterate through
+            ((Iterable<EObject>) result).forEach(EObject -> {/*proxy resolution as a side-effect of traversal*/});                              
+        }
+    }
+    
+    /**
+     * Finds out whether the Resource is currently loading 
+     */
+    public boolean isLoading(Resource resource) {
+        return !resource.isLoaded() || ((Resource.Internal)resource).isLoading();
+    }
+
+}
\ No newline at end of file