41 files changed, 7900 insertions, 0 deletions
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/ViatraBasePlugin.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/ViatraBasePlugin.java
new file mode 100644
index 00000000..96b40825
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/ViatraBasePlugin.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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;
+import org.eclipse.core.runtime.Plugin;
+import tools.refinery.viatra.runtime.base.comprehension.WellbehavingDerivedFeatureRegistry;
+import org.osgi.framework.BundleContext;
+public class ViatraBasePlugin extends Plugin {
+    // The shared instance
+    private static ViatraBasePlugin plugin;
+    public static final String PLUGIN_ID = "tools.refinery.viatra.runtime.base";
+    public static final String WELLBEHAVING_DERIVED_FEATURE_EXTENSION_POINT_ID = "tools.refinery.viatra.runtime.base.wellbehaving.derived.features";
+    @Override
+    public void start(BundleContext context) throws Exception {
+        super.start(context);
+        plugin = this;
+        WellbehavingDerivedFeatureRegistry.initRegistry();
+    }
+    @Override
+    public void stop(BundleContext context) throws Exception {
+        plugin = null;
+        super.stop(context);
+    }
+    /**
+     * Returns the shared instance
+     * 
+     * @return the shared instance
+     */
+    public static ViatraBasePlugin getDefault() {
+        return plugin;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/BaseIndexOptions.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/BaseIndexOptions.java
new file mode 100644
index 00000000..92663400
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/BaseIndexOptions.java
@@ -0,0 +1,395 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import java.util.Objects;
+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;
+import tools.refinery.viatra.runtime.base.api.profiler.ProfilerMode;
+/**
+ * The base index options indicate how the indices are built.
+ * 
+ * <p>
+ * One of the options is to build indices in <em>wildcard mode</em>, meaning that all EClasses, EDataTypes, EReferences
+ * and EAttributes are indexed. This is convenient, but comes at a high memory cost. To save memory, one can disable
+ * <em>wildcard mode</em> and manually register those EClasses, EDataTypes, EReferences and EAttributes that should be
+ * indexed.
+ * </p>
+ * 
+ * <p>
+ * Another choice is whether to build indices in <em>dynamic EMF mode</em>, meaning that types are identified by the
+ * String IDs that are ultimately derived from the nsURI of the EPackage. Multiple types with the same ID are treated as
+ * the same. This is useful if dynamic EMF is used, where there can be multiple copies (instantiations) of the same
+ * EPackage, representing essentially the same metamodel. If one disables <em>dynamic EMF mode</em>, an error is logged
+ * if duplicate EPackages with the same nsURI are encountered.
+ * </p>
+ * 
+ * @author Abel Hegedus
+ * @noimplement This class is not intended to be subclasses outside of VIATRA runtime
+ * 
+ */
+public class BaseIndexOptions {
+    /**
+     * 
+     * By default, base indices will be constructed with wildcard mode set as false.
+     */
+    protected static final IndexingLevel WILDCARD_MODE_DEFAULT = IndexingLevel.NONE;
+    /**
+     * 
+     * By default, base indices will be constructed with only well-behaving features traversed.
+     */
+    private static final boolean TRAVERSE_ONLY_WELLBEHAVING_DERIVED_FEATURES_DEFAULT = true;
+    /**
+     * 
+     * By default, base indices will be constructed with dynamic EMF mode set as false.
+     */
+    protected static final boolean DYNAMIC_EMF_MODE_DEFAULT = false;
+    
+    /**
+     * 
+     * By default, the scope will make the assumption that it is free from dangling edges.
+     * @since 1.6
+     */
+    protected static final boolean DANGLING_FREE_ASSUMPTION_DEFAULT = true;
+    
+    /**
+     * By default, duplicate notifications are only logged.
+     * 
+     * @since 1.6
+     */
+    protected static final boolean STRICT_NOTIFICATION_MODE_DEFAULT = true;
+    
+    /**
+     * @since 2.3
+     */
+    protected static final ProfilerMode INDEX_PROFILER_MODE_DEFAULT = ProfilerMode.OFF;
+    /**
+     * @since 1.6
+     */
+    protected boolean danglingFreeAssumption = DANGLING_FREE_ASSUMPTION_DEFAULT;
+    protected boolean dynamicEMFMode = DYNAMIC_EMF_MODE_DEFAULT;
+    protected boolean traverseOnlyWellBehavingDerivedFeatures = TRAVERSE_ONLY_WELLBEHAVING_DERIVED_FEATURES_DEFAULT;
+    protected IndexingLevel wildcardMode = WILDCARD_MODE_DEFAULT;
+    protected IBaseIndexObjectFilter notifierFilterConfiguration;
+    protected IBaseIndexResourceFilter resourceFilterConfiguration;
+    /**
+     * @since 1.5
+     */
+    protected IBaseIndexFeatureFilter featureFilterConfiguration;
+    
+    /**
+     * If strict notification mode is turned on, errors related to inconsistent notifications, e.g. duplicate deletions
+     * cause the entire Base index to be considered invalid, e.g. the query engine on top of the index should become
+     * tainted.
+     * 
+     * @since 1.6
+     */
+    protected boolean strictNotificationMode = STRICT_NOTIFICATION_MODE_DEFAULT;
+    
+    /**
+     * Returns whether base index profiling should be turned on.
+     * 
+     * @since 2.3
+     */
+    protected ProfilerMode indexerProfilerMode = INDEX_PROFILER_MODE_DEFAULT; 
+    /**
+     * Creates a base index options with the default values.
+     */
+    public BaseIndexOptions() {
+    }
+    
+    /**
+     * Creates a base index options using the provided values for dynamic EMF mode and wildcard mode.
+     * @since 1.4
+     */
+    public BaseIndexOptions(boolean dynamicEMFMode, IndexingLevel wildcardMode) {
+        this.dynamicEMFMode = dynamicEMFMode;
+        this.wildcardMode = wildcardMode;
+    }
+    
+    /**
+     * 
+     * @param dynamicEMFMode
+     * @since 0.9
+     */
+    public BaseIndexOptions withDynamicEMFMode(boolean dynamicEMFMode) {
+        BaseIndexOptions result = copy();
+        result.dynamicEMFMode = dynamicEMFMode;
+        return result;
+    }
+    
+    /**
+     * Sets the dangling edge handling property of the index option. If not set explicitly, it is considered as `true`.
+     * @param danglingFreeAssumption if true, 
+     *  the base index will assume that there are no dangling references 
+     *  (pointing out of scope or to proxies)
+     * @since 1.6
+     */
+    public BaseIndexOptions withDanglingFreeAssumption(boolean danglingFreeAssumption) {
+        BaseIndexOptions result = copy();
+        result.danglingFreeAssumption = danglingFreeAssumption;
+        return result;
+    }
+    
+    /**
+     * Adds an object-level filter to the indexer configuration. Warning - object-level indexing can increase indexing time
+     * noticeably. If possibly, use {@link #withResourceFilterConfiguration(IBaseIndexResourceFilter)} instead.
+     * 
+     * @param filter
+     * @since 0.9
+     */
+    public BaseIndexOptions withObjectFilterConfiguration(IBaseIndexObjectFilter filter) {
+        BaseIndexOptions result = copy();
+        result.notifierFilterConfiguration = filter;
+        return result;
+    }
+    /**
+     * @return the selected object filter configuration, or null if not set
+     */
+    public IBaseIndexObjectFilter getObjectFilterConfiguration() {
+        return notifierFilterConfiguration;
+    }
+    
+    /**
+     * Returns a copy of the configuration with a specified resource filter
+     * 
+     * @param filter
+     * @since 0.9
+     */
+    public BaseIndexOptions withResourceFilterConfiguration(IBaseIndexResourceFilter filter) {
+        BaseIndexOptions result = copy();
+        result.resourceFilterConfiguration = filter;
+        return result;
+    }
+    /**
+     * @return the selected resource filter, or null if not set
+     */
+    public IBaseIndexResourceFilter getResourceFilterConfiguration() {
+        return resourceFilterConfiguration;
+    }
+    
+    
+    /**
+     * Returns a copy of the configuration with a specified feature filter
+     * 
+     * @param filter
+     * @since 1.5
+     */
+    public BaseIndexOptions withFeatureFilterConfiguration(IBaseIndexFeatureFilter filter) {
+        BaseIndexOptions result = copy();
+        result.featureFilterConfiguration = filter;
+        return result;
+    }
+    /**
+     * @return the selected feature filter, or null if not set 
+     * @since 1.5
+     */
+    public IBaseIndexFeatureFilter getFeatureFilterConfiguration() {
+        return featureFilterConfiguration;
+    }
+    
+    /**
+     * @return whether the base index option has dynamic EMF mode set
+     */
+    public boolean isDynamicEMFMode() {
+        return dynamicEMFMode;
+    }
+    /**
+     * @return whether the base index makes the assumption that there can be no dangling edges
+     * @since 1.6
+     */
+    public boolean isDanglingFreeAssumption() {
+        return danglingFreeAssumption;
+    }
+    /**
+     * @return whether the base index option has traverse only well-behaving derived features set
+     */
+    public boolean isTraverseOnlyWellBehavingDerivedFeatures() {
+        return traverseOnlyWellBehavingDerivedFeatures;
+    }
+    
+    /**
+     * 
+     * @param wildcardMode
+     * @since 1.4
+     */
+    public BaseIndexOptions withWildcardLevel(IndexingLevel wildcardLevel) {
+        BaseIndexOptions result = copy();
+        result.wildcardMode = wildcardLevel;
+        return result;
+   }
+    /**
+     * @since 1.6
+     */
+    public BaseIndexOptions withStrictNotificationMode(boolean strictNotificationMode) {
+        BaseIndexOptions result = copy();
+        result.strictNotificationMode = strictNotificationMode;
+        return result;
+    }
+    
+    /**
+     * @since 2.3
+     */
+    public BaseIndexOptions withIndexProfilerMode(ProfilerMode indexerProfilerMode) {
+        BaseIndexOptions result = copy();
+        result.indexerProfilerMode = indexerProfilerMode;
+        return result;
+    }
+    
+    /**
+     * @return whether the base index option has wildcard mode set
+     */
+    public boolean isWildcardMode() {
+        return wildcardMode == IndexingLevel.FULL;
+    }
+    
+    /**
+     * @return the wildcardMode level
+     * @since 1.4
+     */
+    public IndexingLevel getWildcardLevel() {
+        return wildcardMode;
+    }
+    /**
+     * If strict notification mode is turned on, errors related to inconsistent notifications, e.g. duplicate deletions
+     * cause the entire Base index to be considered invalid, e.g. the query engine on top of the index should become
+     * tainted.
+     * 
+     * @since 1.6
+     */
+    public boolean isStrictNotificationMode() {
+        return strictNotificationMode;
+    }
+    /**
+     * Returns whether base indexer profiling is enabled. The profiling causes some slowdown, but provides information
+     * about how much time the base indexer takes for initialization and updates.
+     * 
+     * @since 2.3
+     */
+    public ProfilerMode getIndexerProfilerMode() {
+        return indexerProfilerMode;
+    }
+    /**
+     * Creates an independent copy of itself. The values of each option will be the same as this options. This method is
+     * used when a provided option must be copied to avoid external option changes afterward.
+     * 
+     * @return the copy of this options
+     */
+    public BaseIndexOptions copy() {
+        BaseIndexOptions baseIndexOptions = new BaseIndexOptions(this.dynamicEMFMode, this.wildcardMode);
+        baseIndexOptions.danglingFreeAssumption = this.danglingFreeAssumption;
+        baseIndexOptions.traverseOnlyWellBehavingDerivedFeatures = this.traverseOnlyWellBehavingDerivedFeatures;
+        baseIndexOptions.notifierFilterConfiguration = this.notifierFilterConfiguration;
+        baseIndexOptions.resourceFilterConfiguration = this.resourceFilterConfiguration;
+        baseIndexOptions.featureFilterConfiguration = this.featureFilterConfiguration;
+        baseIndexOptions.strictNotificationMode = this.strictNotificationMode;
+        baseIndexOptions.indexerProfilerMode = this.indexerProfilerMode;
+        return baseIndexOptions;
+    }
+    @Override
+    public int hashCode() {
+        return Objects.hash(dynamicEMFMode, notifierFilterConfiguration, resourceFilterConfiguration,
+                featureFilterConfiguration, traverseOnlyWellBehavingDerivedFeatures, wildcardMode, strictNotificationMode,
+                danglingFreeAssumption, indexerProfilerMode);
+    }
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (!(obj instanceof BaseIndexOptions))
+            return false;
+        BaseIndexOptions other = (BaseIndexOptions) obj;
+        if (dynamicEMFMode != other.dynamicEMFMode)
+            return false;
+        if (danglingFreeAssumption != other.danglingFreeAssumption)
+            return false;
+        if (notifierFilterConfiguration == null) {
+            if (other.notifierFilterConfiguration != null)
+                return false;
+        } else if (!notifierFilterConfiguration
+                .equals(other.notifierFilterConfiguration))
+            return false;
+        if (resourceFilterConfiguration == null) {
+            if (other.resourceFilterConfiguration != null)
+                return false;
+        } else if (!resourceFilterConfiguration
+                .equals(other.resourceFilterConfiguration)){
+            return false;
+        }
+        
+        if (featureFilterConfiguration == null) {
+            if (other.featureFilterConfiguration != null)
+                return false;
+        } else if (!featureFilterConfiguration
+                .equals(other.featureFilterConfiguration)){
+            return false;
+        }
+        
+        if (traverseOnlyWellBehavingDerivedFeatures != other.traverseOnlyWellBehavingDerivedFeatures)
+            return false;
+        if (wildcardMode != other.wildcardMode)
+            return false;
+        if (strictNotificationMode != other.strictNotificationMode) {
+            return false;
+        }
+        if (indexerProfilerMode != other.indexerProfilerMode) {
+            return false;
+        }
+        return true;
+    }
+    
+    
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        appendModifier(sb, dynamicEMFMode, DYNAMIC_EMF_MODE_DEFAULT, "dynamicEMF");
+        appendModifier(sb, wildcardMode, WILDCARD_MODE_DEFAULT, "wildcard");
+        appendModifier(sb, danglingFreeAssumption, DANGLING_FREE_ASSUMPTION_DEFAULT, "danglingFreeAssumption");
+        appendModifier(sb, traverseOnlyWellBehavingDerivedFeatures, TRAVERSE_ONLY_WELLBEHAVING_DERIVED_FEATURES_DEFAULT, "wellBehavingOnly");
+        appendModifier(sb, strictNotificationMode, STRICT_NOTIFICATION_MODE_DEFAULT, "strictNotificationMode");
+        appendModifier(sb, indexerProfilerMode, INDEX_PROFILER_MODE_DEFAULT, "indexerProfilerMode");
+        appendModifier(sb, notifierFilterConfiguration, null, "notifierFilter=");
+        appendModifier(sb, resourceFilterConfiguration, null, "resourceFilter=");
+        appendModifier(sb, featureFilterConfiguration, null, "featureFilterConfiguration=");
+        final String result = sb.toString();
+        return result.isEmpty() ? "defaults" : result;
+    }
+    private static void appendModifier(StringBuilder sb, Object actualValue, Object expectedValue, String switchName) {
+        if (Objects.equals(expectedValue, actualValue)) {
+            // silent
+        } else {
+            sb.append(Boolean.FALSE.equals(actualValue) ? '-' : '+');
+            sb.append(switchName);
+            if (! (actualValue instanceof Boolean)) 
+                sb.append(actualValue);
+        }
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/DataTypeListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/DataTypeListener.java
new file mode 100644
index 00000000..3d30df5e
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/DataTypeListener.java
@@ -0,0 +1,44 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import org.eclipse.emf.ecore.EDataType;
+/**
+ * Interface for observing insertion and deletion of instances of data types.
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public interface DataTypeListener {
+    /**
+     * Called when an instance of the given type is inserted.
+     * 
+     * @param type
+     *            the {@link EDataType}
+     * @param instance
+     *            the instance of the data type
+     * @param firstOccurrence
+     *                    true if this value was not previously present in the model
+     */
+    public void dataTypeInstanceInserted(EDataType type, Object instance, boolean firstOccurrence);
+    /**
+     * Called when an instance of the given type is deleted.
+     * 
+     * @param type
+     *            the {@link EDataType}
+     * @param instance
+     *            the instance of the data type
+     * @param lastOccurrence
+     *                    true if this value is no longer present in the model
+     */
+    public void dataTypeInstanceDeleted(EDataType type, Object instance, boolean lastOccurrence);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/EMFBaseIndexChangeListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/EMFBaseIndexChangeListener.java
new file mode 100644
index 00000000..5a2486f9
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/EMFBaseIndexChangeListener.java
@@ -0,0 +1,33 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+/**
+ * Listener interface for change notifications from the VIATRA Base index.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public interface EMFBaseIndexChangeListener {
+    /**
+     * NOTE: it is possible that this method is called only ONCE! Consider returning a constant value that is set in the constructor.
+     * 
+     * @return true, if the listener should be notified only after index changes, false if notification is needed after each model change 
+     */
+    public boolean onlyOnIndexChange();
+    
+    /**
+     * Called after a model change is handled by the VIATRA Base index and if <code>indexChanged == onlyOnIndexChange()</code>.
+     *  
+     * @param indexChanged true, if the model change also affected the contents of the base index
+     */
+    public void notifyChanged(boolean indexChanged);
+    
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/FeatureListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/FeatureListener.java
new file mode 100644
index 00000000..fa2d679e
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/FeatureListener.java
@@ -0,0 +1,48 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+/**
+ * Interface for observing insertion and deletion of structural feature values ("settings"). (Works both for
+ * single-valued and many-valued features.)
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public interface FeatureListener {
+    /**
+     * Called when the given value is inserted into the given feature of the given host EObject.
+     * 
+     * @param host
+     *            the host (holder) of the feature
+     * @param feature
+     *            the {@link EAttribute} or {@link EReference} instance
+     * @param value
+     *            the target of the feature
+     */
+    public void featureInserted(EObject host, EStructuralFeature feature, Object value);
+    /**
+     * Called when the given value is removed from the given feature of the given host EObject.
+     * 
+     * @param host
+     *            the host (holder) of the feature
+     * @param feature
+     *            the {@link EAttribute} or {@link EReference} instance
+     * @param value
+     *            the target of the feature
+     */
+    public void featureDeleted(EObject host, EStructuralFeature feature, Object value);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEClassifierProcessor.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEClassifierProcessor.java
new file mode 100644
index 00000000..aaa98918
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEClassifierProcessor.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * @author Abel Hegedus
+ *
+ */
+public interface IEClassifierProcessor<ClassType, InstanceType> {
+    
+    void process(ClassType type, InstanceType instance);
+    
+    public interface IEClassProcessor extends IEClassifierProcessor<EClass, EObject>{}
+    public interface IEDataTypeProcessor extends IEClassifierProcessor<EDataType, Object>{}
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEMFIndexingErrorListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEMFIndexingErrorListener.java
new file mode 100644
index 00000000..1dc3291b
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IEMFIndexingErrorListener.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath 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.api;
+/**
+ * 
+ * This interface contains callbacks for various internal errors from the {@link NavigationHelper base index}.
+ * 
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface IEMFIndexingErrorListener {
+    void error(String description, Throwable t);
+    void fatal(String description, Throwable t);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultSetter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultSetter.java
new file mode 100644
index 00000000..717bad4b
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultSetter.java
@@ -0,0 +1,63 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Abel Hegedus, Istvan Rath 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.api;
+/**
+ * Setter interface for query result multimaps that allow modifications of the model through the multimap.
+ * 
+ * <p>
+ * The model modifications should ensure that the multimap changes exactly as required (i.e. a put results in only one
+ * new key-value pair and remove results in only one removed pair).
+ * 
+ * <p>
+ * The input parameters of both put and remove can be validated by implementing the {@link #validate(Object, Object)}
+ * method.
+ * 
+ * @author Abel Hegedus
+ * 
+ * @param <KeyType>
+ * @param <ValueType>
+ */
+public interface IQueryResultSetter<KeyType, ValueType> {
+    /**
+     * Modify the underlying model of the query in order to have the given key-value pair as a new result of the query.
+     * 
+     * @param key
+     *            the key for which a new value is added to the query results
+     * @param value
+     *            the new value that should be added to the query results for the given key
+     * @return true, if the query result changed
+     */
+    boolean put(KeyType key, ValueType value);
+    /**
+     * Modify the underlying model of the query in order to remove the given key-value pair from the results of the
+     * query.
+     * 
+     * @param key
+     *            the key for which the value is removed from the query results
+     * @param value
+     *            the value that should be removed from the query results for the given key
+     * @return true, if the query result changed
+     */
+    boolean remove(KeyType key, ValueType value);
+    /**
+     * Validates a given key-value pair for the query result. The validation has to ensure that (1) if the pair does not
+     * exist in the result, it can be added safely (2) if the pair already exists in the result, it can be removed
+     * safely
+     * 
+     * @param key
+     *            the key of the pair that is validated
+     * @param value
+     *            the value of the pair that is validated
+     * @return true, if the pair does not exists but can be added or the pair exists and can be removed
+     */
+    boolean validate(KeyType key, ValueType value);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultUpdateListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultUpdateListener.java
new file mode 100644
index 00000000..5addfd78
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IQueryResultUpdateListener.java
@@ -0,0 +1,45 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Abel Hegedus, Istvan Rath 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.api;
+/**
+ * Listener interface for receiving notification from {@link QueryResultMultimap}
+ * 
+ * @author Abel Hegedus
+ * 
+ * @param <KeyType>
+ * @param <ValueType>
+ */
+public interface IQueryResultUpdateListener<KeyType, ValueType> {
+    /**
+     * This method is called by the query result multimap when a new key-value pair is put into the multimap
+     * 
+     * <p>
+     * Only invoked if the contents of the multimap changed!
+     * 
+     * @param key
+     *            the key of the newly inserted pair
+     * @param value
+     *            the value of the newly inserted pair
+     */
+    void notifyPut(KeyType key, ValueType value);
+    /**
+     * This method is called by the query result multimap when key-value pair is removed from the multimap
+     * 
+     * <p>
+     * Only invoked if the contents of the multimap changed!
+     * 
+     * @param key
+     *            the key of the removed pair
+     * @param value
+     *            the value of the removed pair
+     */
+    void notifyRemove(KeyType key, ValueType value);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IStructuralFeatureInstanceProcessor.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IStructuralFeatureInstanceProcessor.java
new file mode 100644
index 00000000..208ad761
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IStructuralFeatureInstanceProcessor.java
@@ -0,0 +1,19 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Gabor Bergmann, IncQueryLabs Ltd.
+ * 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.api;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * @author Gabor Bergmann
+ * @since 1.7
+ */
+public interface IStructuralFeatureInstanceProcessor {
+    void process(EObject source, Object target);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IndexingLevel.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IndexingLevel.java
new file mode 100644
index 00000000..df5c59f5
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/IndexingLevel.java
@@ -0,0 +1,113 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQueryLabs
+ * 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.api;
+import tools.refinery.viatra.runtime.matchers.context.IndexingService;
+import java.util.Set;
+/**
+ * The values of this enum denotes the level of indexing the base indexer is capable of.
+ *
+ * @author Grill Balázs
+ * @since 1.4
+ *
+ */
+public enum IndexingLevel {
+    /**
+     * No indexing is performed
+     */
+    NONE,
+    /**
+     * Only cardinality information is stored. This indexing level makes possible to calculate
+     * results of {@link NavigationHelper#countAllInstances(org.eclipse.emf.ecore.EClass)}, {@link NavigationHelper#countFeatures(org.eclipse.emf.ecore.EStructuralFeature)}
+     * and {@link NavigationHelper#countDataTypeInstances(org.eclipse.emf.ecore.EDataType)} with minimal memory footprint.
+     */
+    STATISTICS,
+    /**
+     * Notifications are dispatched about the changes
+     */
+    NOTIFICATIONS,
+    /**
+     * Cardinality information is stored and live notifications are dispatched
+     */
+    BOTH,
+    /**
+     * Full indexing is performed, set of instances is available
+     */
+    FULL
+    ;
+    private static final IndexingLevel[][] mergeTable = {
+                         /* NONE            STATISTICS  NOTIFICATIONS   BOTH     FULL*/
+       /* NONE          */{ NONE,           STATISTICS, NOTIFICATIONS,  BOTH,    FULL},
+       /* STATISTICS    */{ STATISTICS,     STATISTICS, BOTH,           BOTH,    FULL},
+       /* NOTIFICATIONS */{ NOTIFICATIONS,  BOTH,       NOTIFICATIONS,  BOTH,    FULL},
+       /* BOTH          */{ BOTH,           BOTH,       BOTH,           BOTH,    FULL},
+       /* FULL          */{ FULL,           FULL,       FULL,           FULL,    FULL}
+    };
+    public static IndexingLevel toLevel(IndexingService service){
+        switch(service){
+        case INSTANCES:
+            return IndexingLevel.FULL;
+        case NOTIFICATIONS:
+            return IndexingLevel.NOTIFICATIONS;
+        case STATISTICS:
+            return IndexingLevel.STATISTICS;
+        default:
+           return IndexingLevel.NONE;
+        }
+    }
+    public static IndexingLevel toLevel(Set<IndexingService> services){
+        IndexingLevel result = NONE;
+        for(IndexingService service : services){
+            result = result.merge(toLevel(service));
+        }
+        return result;
+    }
+    /**
+     * Merge this level with the given other level, The resulting indexing level will provide the
+     * functionality which conforms to both given levels.
+     */
+    public IndexingLevel merge(IndexingLevel other){
+        if (other == null) return this;
+        return mergeTable[this.ordinal()][other.ordinal()];
+    }
+    /**
+     * Tells whether the indexer shall perform separate statistics calculation for this level
+     */
+    public boolean hasStatistics() {
+        return this == IndexingLevel.BOTH || this == IndexingLevel.STATISTICS || this == IndexingLevel.FULL;
+    }
+    /**
+     * Tells whether the indexer shall perform instance indexing
+     */
+    public boolean hasInstances(){
+        return this == IndexingLevel.FULL;
+    }
+    /**
+     * Returns whether the current indexing level includes all features from the parameter level
+     * @since 1.5
+     */
+    public boolean providesLevel(IndexingLevel level) {
+        return this.merge(level) == this;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/InstanceListener.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/InstanceListener.java
new file mode 100644
index 00000000..6339545d
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/InstanceListener.java
@@ -0,0 +1,41 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+/**
+ * Interface for observing insertion / deletion of instances of EClass.
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public interface InstanceListener {
+    /**
+     * Called when the given instance was added to the model.
+     * 
+     * @param clazz
+     *            an EClass registered for this listener, for which a new instance (possibly an instance of a subclass) was inserted into the model
+     * @param instance
+     *            an EObject instance that was inserted into the model
+     */
+    public void instanceInserted(EClass clazz, EObject instance);
+    /**
+     * Called when the given instance was removed from the model.
+     * 
+     * @param clazz
+     *            an EClass registered for this listener, for which an instance (possibly an instance of a subclass) was removed from the model
+     * @param instance
+     *            an EObject instance that was removed from the model
+     */
+    public void instanceDeleted(EClass clazz, EObject instance);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserver.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserver.java
new file mode 100644
index 00000000..f0245b5d
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserver.java
@@ -0,0 +1,32 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+/**
+ * Listener interface for lightweight observation on EObject feature value changes.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public interface LightweightEObjectObserver {
+    
+    /**
+     * 
+     * @param host
+     * @param feature
+     * @param notification
+     */
+    void notifyFeatureChanged(EObject host, EStructuralFeature feature, Notification notification);
+    
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserverAdapter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserverAdapter.java
new file mode 100644
index 00000000..bcdb8ff4
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/LightweightEObjectObserverAdapter.java
@@ -0,0 +1,74 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import static tools.refinery.viatra.runtime.matchers.util.Preconditions.checkArgument;
+import java.util.Collection;
+import java.util.HashSet;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+/**
+ * Adapter class for lightweight observer which filters feature updates to a selected set of features.
+ * 
+ * @author Abel Hegedus
+ *
+ */
+public abstract class LightweightEObjectObserverAdapter implements LightweightEObjectObserver {
+    private Collection<EStructuralFeature> observedFeatures;
+    
+    /**
+     * Creates a new adapter with the given set of observed features.
+     */
+    public LightweightEObjectObserverAdapter(Collection<EStructuralFeature> observedFeatures) {
+        checkArgument(observedFeatures != null, "List of observed features must not be null!");
+        this.observedFeatures = new HashSet<>(observedFeatures);
+    }
+    
+    public void observeAdditionalFeature(EStructuralFeature observedFeature) {
+        checkArgument(observedFeature != null, "Cannot observe null feature!");
+        this.observedFeatures.add(observedFeature);
+    }
+    
+    public void observeAdditionalFeatures(Collection<EStructuralFeature> observedFeatures) {
+        checkArgument(observedFeatures != null, "List of additional observed features must not be null!");
+        this.observedFeatures.addAll(observedFeatures);
+    }
+    
+    public void removeObservedFeature(EStructuralFeature observedFeature) {
+        checkArgument(observedFeature != null, "Cannot remove null observed feature!");
+        this.observedFeatures.remove(observedFeature);
+    }
+    
+    public void removeObservedFeatures(Collection<EStructuralFeature> observedFeatures) {
+        checkArgument(observedFeatures != null, "List of observed features to remove must not be null!");
+        this.observedFeatures.removeAll(observedFeatures);
+    }
+    
+    @Override
+    public void notifyFeatureChanged(EObject host, EStructuralFeature feature, Notification notification) {
+        if(this.observedFeatures.contains(feature)) {
+            observedFeatureUpdate(host, feature, notification);
+        }
+    }
+    
+    /**
+     * This method is called when the feature that changed is among the observed features of the adapter.
+     * 
+     * @param host
+     * @param feature
+     * @param notification
+     */
+    public abstract void observedFeatureUpdate(EObject host, EStructuralFeature feature, Notification notification);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/NavigationHelper.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/NavigationHelper.java
new file mode 100644
index 00000000..6a9f704b
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/NavigationHelper.java
@@ -0,0 +1,885 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.common.util.Enumerator;
+import org.eclipse.emf.ecore.*;
+import org.eclipse.emf.ecore.EStructuralFeature.Setting;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import tools.refinery.viatra.runtime.base.api.IEClassifierProcessor.IEClassProcessor;
+import tools.refinery.viatra.runtime.base.api.IEClassifierProcessor.IEDataTypeProcessor;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.ConcurrentModificationException;
+import java.util.Set;
+import java.util.concurrent.Callable;
+/**
+ *
+ * Using an index of the EMF model, this interface exposes useful query functionality, such as:
+ * <ul>
+ * <li>
+ * Getting all the (direct or descendant) instances of a given {@link EClass}
+ * <li>
+ * Inverse navigation along arbitrary {@link EReference} instances (heterogenous paths too)
+ * <li>
+ * Finding model elements by attribute value (i.e. inverse navigation along {@link EAttribute})
+ * <li>
+ * Querying instances of given data types, or structural features.
+ * </ul>
+ * As queries are served from an index, results are always instantaneous.
+ *
+ * <p>
+ * Such indices will be built on an EMF model rooted at an {@link EObject}, {@link Resource} or {@link ResourceSet}.
+ * The boundaries of the model are defined by the containment (sub)tree.
+ * The indices will be <strong>maintained incrementally</strong> on changes to the model; these updates can also be
+ * observed by registering listeners.
+ * </p>
+ *
+ * <p>
+ * One of the options is to build indices in <em>wildcard mode</em>, meaning that all EClasses, EDataTypes, EReferences
+ * and EAttributes are indexed. This is convenient, but comes at a high memory cost. To save memory, one can disable
+ * <em>wildcard mode</em> and manually register those EClasses, EDataTypes, EReferences and EAttributes that should be
+ * indexed.
+ * </p>
+ *
+ * <p>
+ * Another choice is whether to build indices in <em>dynamic EMF mode</em>, meaning that types are identified by the String IDs
+ * that are ultimately derived from the nsURI of the EPackage. Multiple types with the same ID are treated as the same.
+ * This is useful if dynamic EMF is used, where there can be multiple copies (instantiations) of the same EPackage,
+ * representing essentially the same metamodel. If one disables <em>dynamic EMF mode</em>, an error is logged if
+ * duplicate EPackages with the same nsURI are encountered.
+ * </p>
+ *
+ * <p>
+ * Note that none of the defined query methods return null upon empty result sets. All query methods return either a copy of
+ * the result sets (where {@link Setting} is instantiated) or an unmodifiable collection of the result view.
+ *
+ * <p>
+ * Instantiate using {@link ViatraBaseFactory}
+ *
+ * @author Tamas Szabo
+ * @noimplement This interface is not intended to be implemented by clients.
+ *
+ */
+public interface NavigationHelper {
+    /**
+     * Indicates whether indexing is performed in <em>wildcard mode</em>, where every aspect of the EMF model is
+     * automatically indexed.
+     *
+     * @return true if everything is indexed, false if manual registration of interesting EClassifiers and
+     *         EStructuralFeatures is required.
+     */
+    public boolean isInWildcardMode();
+    /**
+     * Indicates whether indexing is performed in <em>wildcard mode</em> for a selected indexing level
+     *
+     * @return true if everything is indexed, false if manual registration of interesting EClassifiers and
+     *         EStructuralFeatures is required.
+     * @since 1.5
+     */
+    public boolean isInWildcardMode(IndexingLevel level);
+    /**
+     * Returns the current {@link IndexingLevel} applied to all model elements. For specific types it is possible to request a higher indexing levels, but cannot be lowered.
+     * @return the current level of index specified
+     * @since 1.4
+     */
+    public IndexingLevel getWildcardLevel();
+    /**
+     * Starts wildcard indexing at the given level. After this call, no registration is required for this {@link IndexingLevel}.
+     * a previously set wildcard level cannot be lowered, only extended.
+     *
+     * @since 1.4
+     */
+    public void setWildcardLevel(IndexingLevel level);
+    /**
+     * Indicates whether indexing is performed in <em>dynamic EMF mode</em>, i.e. EPackage nsURI collisions are
+     *   tolerated and EPackages with the same URI are automatically considered as equal.
+     *
+     * @return true if multiple EPackages with the same nsURI are treated as the same,
+     *         false if an error is logged instead in this case.
+     */
+    public boolean isInDynamicEMFMode();
+    /**
+     * For a given attribute value <code>value</code>, find each {@link EAttribute} and host {@link EObject}
+     * such that this attribute of the the host object takes the given value. The method will
+     * return a set of {@link Setting}s, one for each such host object - EAttribute - value triplet.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null attribute values are not indexed, so <code>value!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Will only find those EAttributes that have already been registered using
+     * {@link #registerEStructuralFeatures(Set)}, unless running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param value
+     *            the value of the attribute
+     * @return a set of {@link Setting}s, one for each EObject and EAttribute that have the given value
+     * @see #findByAttributeValue(Object)
+     */
+    public Set<Setting> findByAttributeValue(Object value);
+    /**
+     * For given <code>attributes</code> and an attribute value <code>value</code>, find each host {@link EObject}
+     * such that any of these attributes of the the host object takes the given value. The method will
+     * return a set of {@link Setting}s, one for each such host object - EAttribute - value triplet.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null attribute values are not indexed, so <code>value!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Will only find those EAttributes that have already been registered using
+     * {@link #registerEStructuralFeatures(Set)}, unless running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param value
+     *            the value of the attribute
+     * @param attributes
+     *            the collection of attributes that should take the given value
+     * @return a set of {@link Setting}s, one for each EObject and attribute that have the given value
+     */
+    public Set<Setting> findByAttributeValue(Object value, Collection<EAttribute> attributes);
+    /**
+     * Find all {@link EObject}s for which the given <code>attribute</code> takes the given <code>value</code>.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null attribute values are not indexed, so <code>value!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the EAttribute has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param value
+     *            the value of the attribute
+     * @param attribute
+     *            the EAttribute that should take the given value
+     * @return the set of {@link EObject}s for which the given attribute has the given value
+     */
+    public Set<EObject> findByAttributeValue(Object value, EAttribute attribute);
+    /**
+     * Returns the set of instances for the given {@link EDataType} that can be found in the model.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the EDataType has already been
+     * registered using {@link #registerEDataTypes(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param type
+     *            the data type
+     * @return the set of all attribute values found in the model that are of the given data type
+     */
+    public Set<Object> getDataTypeInstances(EDataType type);
+    /**
+     * Returns whether an object is an instance for the given {@link EDataType} that can be found in the current scope.
+     * <p>
+     * <strong>Precondition:</strong> Result will be true only if either (a) the EDataType has already been registered
+     * using {@link #registerEDataTypes(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param value a non-null value to decide whether it is available as an EDataType instance
+     * @param type a non-null EDataType
+     * @return true, if a corresponding instance was found
+     * @since 1.7
+     */
+    public boolean isInstanceOfDatatype(Object value, EDataType type);
+    /**
+     * Find all {@link EObject}s that are the target of the EReference <code>reference</code> from the given
+     * <code>source</code> {@link EObject}.
+     *
+     * <p>
+     * Unset / null-valued references are not indexed, and will not be included in the results.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the reference has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param source the host object
+     * @param reference an EReference of the host object
+     * @return the set of {@link EObject}s that the given reference points to, from the given source object
+     */
+    public Set<EObject> getReferenceValues(EObject source, EReference reference);
+    /**
+     * Find all {@link Object}s that are the target of the EStructuralFeature <code>feature</code> from the given
+     * <code>source</code> {@link EObject}.
+     *
+     * <p>
+     * Unset / null-valued features are not indexed, and will not be included in the results.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the feature has already been
+     * registered, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param source the host object
+     * @param feature an EStructuralFeature of the host object
+     * @return the set of values that the given feature takes at the given source object
+     *
+     * @see #getReferenceValues(EObject, EReference)
+     */
+    public Set<Object> getFeatureTargets(EObject source, EStructuralFeature feature);
+    /**
+     * Decides whether the given non-null source and target objects are connected via a specific, indexed EStructuralFeature instance.
+     *
+     * <p>
+     * Unset / null-valued features are not indexed, and will not be included in the results.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Result will be true only if either (a) the feature has already been
+     * registered, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     * @since 1.7
+     */
+    public boolean isFeatureInstance(EObject source, Object target, EStructuralFeature feature);
+    /**
+     * For a given {@link EObject} <code>target</code>, find each {@link EReference} and source {@link EObject}
+     * such that this reference (list) of the the host object points to the given target object. The method will
+     * return a set of {@link Setting}s, one for each such source object - EReference - target triplet.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null reference values are not indexed, so <code>target!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only for those references that have already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or all references if running in
+     * <em>wildcard mode</em> (see {@link #isInWildcardMode()}).
+     *
+     * @param target
+     *            the EObject pointed to by the references
+     * @return a set of {@link Setting}s, one for each source EObject and reference that point to the given target
+     */
+    public Set<Setting> getInverseReferences(EObject target);
+    /**
+     * For given <code>references</code> and an {@link EObject} <code>target</code>, find each source {@link EObject}
+     * such that any of these references of the the source object points to the given target object. The method will
+     * return a set of {@link Setting}s, one for each such source object - EReference - target triplet.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null reference values are not indexed, so <code>target!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Will only find those EReferences that have already been registered using
+     * {@link #registerEStructuralFeatures(Set)}, unless running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param target
+     *            the EObject pointed to by the references
+     * @param references a set of EReferences pointing to the target
+     * @return a set of {@link Setting}s, one for each source EObject and reference that point to the given target
+     */
+    public Set<Setting> getInverseReferences(EObject target, Collection<EReference> references);
+    /**
+     * Find all source {@link EObject}s for which the given <code>reference</code> points to the given <code>target</code> object.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null reference values are not indexed, so <code>target!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the reference has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param target
+     *            the EObject pointed to by the references
+     * @param reference
+     *            an EReference pointing to the target
+     * @return the collection of {@link EObject}s for which the given reference points to the given target object
+     */
+    public Set<EObject> getInverseReferences(EObject target, EReference reference);
+    /**
+     * Get the direct {@link EObject} instances of the given {@link EClass}. Instances of subclasses will be excluded.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the EClass (or any superclass) has
+     * already been registered using {@link #registerEClasses(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param clazz
+     *            an EClass
+     * @return the collection of {@link EObject} direct instances of the given EClass (not of subclasses)
+     *
+     * @see #getAllInstances(EClass)
+     */
+    public Set<EObject> getDirectInstances(EClass clazz);
+    /**
+     * Get the all {@link EObject} instances of the given {@link EClass}.
+     * This includes instances of subclasses.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the EClass (or any superclass) has
+     * already been registered using {@link #registerEClasses(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param clazz
+     *            an EClass
+     * @return the collection of {@link EObject} instances of the given EClass and any of its subclasses
+     *
+     * @see #getDirectInstances(EClass)
+     */
+    public Set<EObject> getAllInstances(EClass clazz);
+    /**
+     * Checks whether the given {@link EObject} is an instance of the given {@link EClass}.
+     * This includes instances of subclasses.
+     * <p> Special note: this method does not check whether the object is indexed in the scope,
+     * and will return true for out-of-scope objects as well (as long as they are instances of the class).
+     * <p> The given class does not have to be indexed.
+     * <p> The difference between this method and {@link EClassifier#isInstance(Object)} is that in dynamic EMF mode, EPackage equivalence is taken into account.
+     * @since 1.6
+     */
+    public boolean isInstanceOfUnscoped(EObject object, EClass clazz);
+    /**
+     * Checks whether the given {@link EObject} is an instance of the given {@link EClass}.
+     * This includes instances of subclasses.
+     * <p> Special note: this method does check whether the object is indexed in the scope,
+     * and will return false for out-of-scope objects as well (as long as they are instances of the class).
+     * <p> The given class does have to be indexed.
+     * @since 1.7
+     */
+    public boolean isInstanceOfScoped(EObject object, EClass clazz);
+    /**
+     * Get the total number of instances of the given {@link EClass} and all of its subclasses.
+     *
+     * @since 1.4
+     */
+    public int countAllInstances(EClass clazz);
+    /**
+     * Find all source {@link EObject}s for which the given <code>feature</code> points to / takes the given <code>value</code>.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Unset / null-valued features are not indexed, so <code>value!=null</code>
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the feature has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param value
+     *            the value of the feature
+     * @param feature
+     *            the feature instance
+     * @return the collection of {@link EObject} instances
+     */
+    public Set<EObject> findByFeatureValue(Object value, EStructuralFeature feature);
+    /**
+     * Returns those host {@link EObject}s that have a non-null value for the given feature
+     * (at least one, in case of multi-valued references).
+     *
+     * <p>
+     * Unset / null-valued features are not indexed, and will not be included in the results.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the feature has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param feature
+     *            a structural feature
+     * @return the collection of {@link EObject}s that have some value for the given structural feature
+     */
+    public Set<EObject> getHoldersOfFeature(EStructuralFeature feature);
+    /**
+     * Returns all non-null values that the given feature takes at least once for any {@link EObject} in the scope
+     *
+     * <p>
+     * Unset / null-valued features are not indexed, and will not be included in the results.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Results will be returned only if either (a) the feature has already been
+     * registered using {@link #registerEStructuralFeatures(Set)}, or (b) running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @param feature
+     *            a structural feature
+     * @return the collection of values that the given structural feature takes
+     * @since 2.1
+     */
+    public Set<Object> getValuesOfFeature(EStructuralFeature feature);
+    /**
+     * Call this method to dispose the NavigationHelper.
+     *
+     * <p>After its disposal, the NavigationHelper will no longer listen to EMF change notifications,
+     *   and it will be possible to GC it even if the model is retained in memory.
+     *
+     * <dt><b>Precondition:</b><dd> no listeners can be registered at all.
+     * @throws IllegalStateException if there are any active listeners
+     *
+     */
+    public void dispose();
+    /**
+     * The given <code>listener</code> will be notified from now on whenever instances the given {@link EClass}es
+     * (and any of their subtypes) are added to or removed from the model.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link InstanceListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to add a listener
+     * at that point, wrap the call with {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param classes
+     *            the collection of classes whose instances the listener should be notified of
+     * @param listener
+     *            the listener instance
+     */
+    public void addInstanceListener(Collection<EClass> classes, InstanceListener listener);
+    /**
+     * Unregisters an instance listener for the given classes.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link InstanceListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to remove a listener at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param classes
+     *            the collection of classes
+     * @param listener
+     *            the listener instance
+     */
+    public void removeInstanceListener(Collection<EClass> classes, InstanceListener listener);
+    /**
+     * The given <code>listener</code> will be notified from now on whenever instances the given {@link EDataType}s are
+     * added to or removed from the model.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link DataTypeListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to add a listener at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param types
+     *            the collection of types associated to the listener
+     * @param listener
+     *            the listener instance
+     */
+    public void addDataTypeListener(Collection<EDataType> types, DataTypeListener listener);
+    /**
+     * Unregisters a data type listener for the given types.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link DataTypeListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to remove a listener at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param types
+     *            the collection of data types
+     * @param listener
+     *            the listener instance
+     */
+    public void removeDataTypeListener(Collection<EDataType> types, DataTypeListener listener);
+    /**
+     * The given <code>listener</code> will be notified from now on whenever instances the given
+     * {@link EStructuralFeature}s are added to or removed from the model.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link FeatureListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to add a listener at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param features
+     *            the collection of features associated to the listener
+     * @param listener
+     *            the listener instance
+     */
+    public void addFeatureListener(Collection<? extends EStructuralFeature> features, FeatureListener listener);
+    /**
+     * Unregisters a feature listener for the given features.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link FeatureListener} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to remove a listener at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param listener
+     *            the listener instance
+     * @param features
+     *            the collection of features
+     */
+    public void removeFeatureListener(Collection<? extends EStructuralFeature> features, FeatureListener listener);
+    /**
+     * Register a lightweight observer that is notified if the value of any feature of the given EObject changes.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link LightweightEObjectObserver} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to add an observer at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param observer
+     *            the listener instance
+     * @param observedObject
+     *            the observed EObject
+     * @return false if the observer was already attached to the object (call has no effect), true otherwise
+     */
+    public boolean addLightweightEObjectObserver(LightweightEObjectObserver observer, EObject observedObject);
+    /**
+     * Unregisters a lightweight observer for the given EObject.
+     *
+     * <br/>
+     * <b>Important</b>: Do not call this method from {@link LightweightEObjectObserver} methods as it may cause a
+     * {@link ConcurrentModificationException}, if you want to remove an observer at that point, wrap the call with
+     * {@link #executeAfterTraversal(Runnable)}.
+     *
+     * @param observer
+     *            the listener instance
+     * @param observedObject
+     *            the observed EObject
+     * @return false if the observer has not been previously attached to the object (call has no effect), true otherwise
+     */
+    public boolean removeLightweightEObjectObserver(LightweightEObjectObserver observer, EObject observedObject);
+    /**
+     * Manually turns on indexing for the given types (indexing of others are unaffected). Note that
+     * registering new types will result in a single iteration through the whole attached model.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * @param classes
+     *            the set of classes to observe (null okay)
+     * @param dataTypes
+     *            the set of data types to observe (null okay)
+     * @param features
+     *            the set of features to observe (null okay)
+     * @throws IllegalStateException if in wildcard mode
+     * @since 1.4
+     */
+    public void registerObservedTypes(Set<EClass> classes, Set<EDataType> dataTypes, Set<? extends EStructuralFeature> features, IndexingLevel level);
+    /**
+     * Manually turns off indexing for the given types (indexing of others are unaffected). Note that if the
+     * unregistered types are re-registered later, the whole attached model needs to be visited again.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * <dt><b>Precondition:</b><dd> no listeners can be registered for the given types.
+     * @param classes
+     *            the set of classes that will be ignored again from now on (null okay)
+     * @param dataTypes
+     *            the set of data types that will be ignored again from now on (null okay)
+     * @param features
+     *            the set of features that will be ignored again from now on (null okay)
+     * @throws IllegalStateException if in wildcard mode, or if there are listeners registered for the given types
+     */
+    public void unregisterObservedTypes(Set<EClass> classes, Set<EDataType> dataTypes, Set<? extends EStructuralFeature> features);
+    /**
+     * Manually turns on indexing for the given features (indexing of other features are unaffected). Note that
+     * registering new features will result in a single iteration through the whole attached model.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * @param features
+     *            the set of features to observe
+     * @throws IllegalStateException if in wildcard mode
+     * @since 1.4
+     */
+    public void registerEStructuralFeatures(Set<? extends EStructuralFeature> features, IndexingLevel level);
+    /**
+     * Manually turns off indexing for the given features (indexing of other features are unaffected). Note that if the
+     * unregistered features are re-registered later, the whole attached model needs to be visited again.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * <dt><b>Precondition:</b><dd> no listeners can be registered for the given features.
+     *
+     * @param features
+     *            the set of features that will be ignored again from now on
+     * @throws IllegalStateException if in wildcard mode, or if there are listeners registered for the given types
+     */
+    public void unregisterEStructuralFeatures(Set<? extends EStructuralFeature> features);
+    /**
+     * Manually turns on indexing for the given classes (indexing of other classes are unaffected). Instances of
+     * subclasses will also be indexed. Note that registering new classes will result in a single iteration through the whole
+     * attached model.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * @param classes
+     *            the set of classes to observe
+     * @throws IllegalStateException if in wildcard mode
+     * @since 1.4
+     */
+    public void registerEClasses(Set<EClass> classes, IndexingLevel level);
+    /**
+     * Manually turns off indexing for the given classes (indexing of other classes are unaffected). Note that if the
+     * unregistered classes are re-registered later, the whole attached model needs to be visited again.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * <dt><b>Precondition:</b><dd> no listeners can be registered for the given classes.
+     * @param classes
+     *            the set of classes that will be ignored again from now on
+     * @throws IllegalStateException if in wildcard mode, or if there are listeners registered for the given types
+     */
+    public void unregisterEClasses(Set<EClass> classes);
+    /**
+     * Manually turns on indexing for the given data types (indexing of other features are unaffected). Note that
+     * registering new data types will result in a single iteration through the whole attached model.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * @param dataTypes
+     *            the set of data types to observe
+     * @throws IllegalStateException if in wildcard mode
+     * @since 1.4
+     */
+    public void registerEDataTypes(Set<EDataType> dataTypes, IndexingLevel level);
+    /**
+     * Manually turns off indexing for the given data types (indexing of other data types are unaffected). Note that if
+     * the unregistered data types are re-registered later, the whole attached model needs to be visited again.
+     * <b> Not usable in <em>wildcard mode</em>.</b>
+     *
+     * <dt><b>Precondition:</b><dd> no listeners can be registered for the given datatypes.
+     *
+     * @param dataTypes
+     *            the set of data types that will be ignored again from now on
+     * @throws IllegalStateException if in wildcard mode, or if there are listeners registered for the given types
+     */
+    public void unregisterEDataTypes(Set<EDataType> dataTypes);
+    /**
+     * The given callback will be executed, and all model traversals and index registrations will be delayed until the
+     * execution is done. If there are any outstanding feature, class or datatype registrations, a single coalesced model
+     * traversal will initialize the caches and deliver the notifications.
+     *
+     * @param callable
+     */
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException;
+    /**
+     * Execute the given runnable after traversal. It is guaranteed that the runnable is executed as soon as
+     * the indexing is finished. The callback is executed only once, then is removed from the callback queue.
+     * @param traversalCallback
+     * @throws InvocationTargetException
+     * @since 1.4
+     */
+    public void executeAfterTraversal(Runnable traversalCallback) throws InvocationTargetException;
+    /**
+     * Examines whether execution is currently in the callable
+     *  block of an invocation of {#link {@link #coalesceTraversals(Callable)}}.
+     */
+    public boolean isCoalescing();
+    /**
+     * Adds a coarse-grained listener that will be invoked after the NavigationHelper index or the underlying model is changed. Can be used
+     * e.g. to check model contents. Not intended for general use.
+     *
+     * <p/> See {@link #removeBaseIndexChangeListener(EMFBaseIndexChangeListener)}
+     * @param listener
+     */
+    public void addBaseIndexChangeListener(EMFBaseIndexChangeListener listener);
+    /**
+     * Removes a registered listener.
+     *
+     * <p/> See {@link #addBaseIndexChangeListener(EMFBaseIndexChangeListener)}
+     *
+     * @param listener
+     */
+    public void removeBaseIndexChangeListener(EMFBaseIndexChangeListener listener);
+    /**
+     * Adds an additional EMF model root.
+     *
+     * @param emfRoot
+     * @throws ViatraQueryRuntimeException
+     */
+    public void addRoot(Notifier emfRoot);
+    /**
+     * Moves an EObject (along with its entire containment subtree) within the containment hierarchy of the EMF model.
+     *   The object will be relocated from the original parent object to a different parent, or a different containment
+     *   list of the same parent.
+     *
+     * <p> When indexing is enabled, such a relocation is costly if performed through normal getters/setters, as the index
+     * for the entire subtree is pruned at the old location and reconstructed at the new one.
+     * This method provides a workaround to keep the operation cheap.
+     *
+     * <p> This method is experimental. Re-entrancy not supported.
+     *
+     * @param element the eObject to be moved
+     * @param targetContainmentReferenceList containment list of the new parent object into which the element has to be moved
+     *
+     */
+    public <T extends EObject> void cheapMoveTo(T element, EList<T> targetContainmentReferenceList);
+    /**
+     * Moves an EObject (along with its entire containment subtree) within the containment hierarchy of the EMF model.
+     *   The object will be relocated from the original parent object to a different parent, or a different containment
+     *   list of the same parent.
+     *
+     * <p> When indexing is enabled, such a relocation is costly if performed through normal getters/setters, as the index
+     * for the entire subtree is pruned at the old location and reconstructed at the new one.
+     * This method provides a workaround to keep the operation cheap.
+     *
+     * <p> This method is experimental. Re-entrancy not supported.
+     *
+     * @param element the eObject to be moved
+     * @param parent  the new parent object under which the element has to be moved
+     * @param containmentFeature the kind of containment reference that should be established between the new parent and the element
+     *
+     */
+    public void cheapMoveTo(EObject element, EObject parent, EReference containmentFeature);
+    /**
+     * Traverses all instances of a selected data type stored in the base index, and allows executing a custom function on
+     * it. There is no guaranteed order in which the processor will be called with the selected features.
+     *
+     * @param type
+     * @param processor
+     * @since 0.8
+     */
+    void processDataTypeInstances(EDataType type, IEDataTypeProcessor processor);
+    /**
+     * Traverses all direct instances of a selected class stored in the base index, and allows executing a custom function on
+     * it. There is no guaranteed order in which the processor will be called with the selected features.
+     *
+     * @param type
+     * @param processor
+     * @since 0.8
+     */
+    void processAllInstances(EClass type, IEClassProcessor processor);
+    /**
+     * Traverses all direct instances of a selected class stored in the base index, and allows executing a custom function on
+     * it. There is no guaranteed order in which the processor will be called with the selected features.
+     *
+     * @param type
+     * @param processor
+     * @since 0.8
+     */
+    void processDirectInstances(EClass type, IEClassProcessor processor);
+    /**
+     * Traverses all instances of a selected feature stored in the base index, and allows executing a custom function on
+     * it. There is no guaranteed order in which the processor will be called with the selected features.
+     *
+     * <p>
+     * <strong>Precondition:</strong> Will only find those {@link EStructuralFeature}s that have already been registered using
+     * {@link #registerEStructuralFeatures(Set)}, unless running in <em>wildcard mode</em> (see
+     * {@link #isInWildcardMode()}).
+     *
+     * @since 1.7
+     */
+    void processAllFeatureInstances(EStructuralFeature feature, IStructuralFeatureInstanceProcessor processor);
+    /**
+     * Returns all EClasses that currently have direct instances cached by the index. <ul>
+     * <li> Supertypes will not be returned, unless they have direct instances in the model as well.
+     * <li> If not in <em>wildcard mode</em>, only registered EClasses and their subtypes will be considered.
+     * <li> Note for advanced users: if a type is represented by multiple EClass objects, one of them is chosen as representative and returned.
+     * </ul>
+     */
+    public Set<EClass> getAllCurrentClasses();
+    /**
+     * Updates the value of indexed derived features that are not well-behaving.
+     */
+    void resampleDerivedFeatures();
+    /**
+     * Adds a listener for internal errors in the index. A listener can only be added once.
+     *
+     * @param listener
+     * @returns true if the listener was not already added
+     * @since 0.8
+     */
+    boolean addIndexingErrorListener(IEMFIndexingErrorListener listener);
+    /**
+     * Removes a listener for internal errors in the index.
+     *
+     * @param listener
+     * @returns true if the listener was successfully removed (e.g. it did exist)
+     * @since 0.8
+     */
+    boolean removeIndexingErrorListener(IEMFIndexingErrorListener listener);
+    /**
+     * Returns the internal, canonicalized implementation of an attribute value.
+     *
+     * <p> Behaviour: when in dynamic EMF mode, substitutes enum literals with a canonical version of the enum literal.
+     * Otherwise, returns the input.
+     *
+     * <p> The canonical enum literal will be guaranteed to be a valid EMF enum literal ({@link Enumerator}),
+     *  and the best effort is made to ensure that it will be the same for all versions of the {@link EEnum},
+     *  including {@link EEnumLiteral}s in different versions of ecore packages, as well as Java enums generated from them..
+     *
+     * <p> Usage is not required when simply querying the indexed model through the {@link NavigationHelper} API,
+     *  as both method inputs and the results returned are automatically canonicalized in dynamic EMF mode.
+     * Using this method is required only if the client wants to do querying/filtering on the results returned, and wants to know what to look for.
+     */
+    Object toCanonicalValueRepresentation(Object value);
+    /**
+     * @since 1.4
+     */
+    IndexingLevel getIndexingLevel(EClass type);
+    /**
+     * @since 1.4
+     */
+    IndexingLevel getIndexingLevel(EDataType type);
+    /**
+     * @since 1.4
+     */
+    IndexingLevel getIndexingLevel(EStructuralFeature feature);
+    /**
+     * @since 1.4
+     */
+    public int countDataTypeInstances(EDataType dataType);
+    /**
+     * @since 1.4
+     */
+    public int countFeatureTargets(EObject seedSource, EStructuralFeature feature);
+    /**
+     * @since 1.4
+     */
+    public int countFeatures(EStructuralFeature feature);
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultAssociativeStore.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultAssociativeStore.java
new file mode 100644
index 00000000..27d08506
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultAssociativeStore.java
@@ -0,0 +1,322 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Map.Entry;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+/**
+ * @author Abel Hegedus
+ *
+ */
+public abstract class QueryResultAssociativeStore<KeyType, ValueType> {
+    /**
+     * Error literal returned when associative store modification is attempted without a setter available
+     */
+    protected static final String NOT_ALLOW_MODIFICATIONS = "Query result associative store does not allow modifications";
+    
+    /**
+     * Logger that can be used for reporting errors during runtime
+     */
+    private Logger logger;
+    /**
+     * The collection of listeners registered for this result associative store
+     */
+    private Collection<IQueryResultUpdateListener<KeyType, ValueType>> listeners;
+    /**
+     * The setter registered for changing the contents of the associative store
+     */
+    private IQueryResultSetter<KeyType, ValueType> setter;
+    /**
+     * @return the listeners
+     */
+    protected Collection<IQueryResultUpdateListener<KeyType, ValueType>> getListeners() {
+        return listeners;
+    }
+    /**
+     * @param listeners the listeners to set
+     */
+    protected void setListeners(Collection<IQueryResultUpdateListener<KeyType, ValueType>> listeners) {
+        this.listeners = listeners;
+    }
+    /**
+     * @return the setter
+     */
+    protected IQueryResultSetter<KeyType, ValueType> getSetter() {
+        return setter;
+    }
+    /**
+     * @param setter the setter to set
+     */
+    protected void setSetter(IQueryResultSetter<KeyType, ValueType> setter) {
+        this.setter = setter;
+    }
+    /**
+     * @param logger the logger to set
+     */
+    protected void setLogger(Logger logger) {
+        this.logger = logger;
+    }
+    /**
+     * Returns the entries in the cache as a collection.
+     * @return the entries
+     */
+    protected abstract Collection<Entry<KeyType, ValueType>> getCacheEntries();
+    
+    /**
+     * Registers a listener for this query result associative store that is invoked every time when a key-value pair is inserted
+     * or removed from the associative store.
+     * 
+     * <p>
+     * The listener can be unregistered via {@link #removeCallbackOnQueryResultUpdate(IQueryResultUpdateListener)}.
+     * 
+     * @param listener
+     *            the listener that will be notified of each key-value pair that is inserted or removed, starting from
+     *            now.
+     * @param fireNow
+     *            if true, notifyPut will be immediately invoked on all current key-values as a one-time effect.
+     */
+    public void addCallbackOnQueryResultUpdate(IQueryResultUpdateListener<KeyType, ValueType> listener, boolean fireNow) {
+        if (listeners == null) {
+            listeners = new HashSet<IQueryResultUpdateListener<KeyType, ValueType>>();
+        }
+        listeners.add(listener);
+        if(fireNow) {
+            for (Entry<KeyType, ValueType> entry : getCacheEntries()) {
+                sendNotificationToListener(Direction.INSERT, entry.getKey(), entry.getValue(), listener);
+            }
+        }
+    }
+    
+    /**
+     * Unregisters a callback registered by {@link #addCallbackOnQueryResultUpdate(IQueryResultUpdateListener, boolean)}
+     * .
+     * 
+     * @param listener
+     *            the listener that will no longer be notified.
+     */
+    public void removeCallbackOnQueryResultUpdate(IQueryResultUpdateListener<KeyType, ValueType> listener) {
+        if (listeners != null) {
+            listeners.remove(listener);
+        }
+    }
+    /**
+     * This method notifies the listeners that the query result associative store has changed.
+     * 
+     * @param direction
+     *            the type of the change (insert or delete)
+     * @param key
+     *            the key of the pair that changed
+     * @param value
+     *            the value of the pair that changed
+     */
+    protected void notifyListeners(Direction direction, KeyType key, ValueType value) {
+        if(listeners != null) {
+            for (IQueryResultUpdateListener<KeyType, ValueType> listener : listeners) {
+                sendNotificationToListener(direction, key, value, listener);
+            }
+        }
+    }
+    private void sendNotificationToListener(Direction direction, KeyType key, ValueType value,
+            IQueryResultUpdateListener<KeyType, ValueType> listener) {
+        try {
+            if (direction == Direction.INSERT) {
+                listener.notifyPut(key, value);
+            } else {
+                listener.notifyRemove(key, value);
+            }
+        } catch (Exception e) { // NOPMD
+            logger.warn(
+                    String.format(
+                            "The query result associative store encountered an error during executing a callback on %s of key %s and value %s. Error message: %s. (Developer note: %s in %s called from QueryResultMultimap)",
+                            direction == Direction.INSERT ? "insertion" : "removal", key, value, e.getMessage(), e
+                                    .getClass().getSimpleName(), listener), e);
+            throw new IllegalStateException("The query result associative store encountered an error during invoking setter",e);
+        }
+    }
+    
+    /**
+     * Implementations of QueryResultAssociativeStore can put a new key-value pair into the associative store with this method. If the
+     * insertion of the key-value pair results in a change, the listeners are notified.
+     * 
+     * <p>
+     * No validation or null-checking is performed during the method!
+     * 
+     * @param key
+     *            the key which identifies where the new value is put
+     * @param value
+     *            the value that is put into the collection of the key
+     * @return true, if the insertion resulted in a change (the key-value pair was not yet in the associative store)
+     */
+    protected boolean internalPut(KeyType key, ValueType value){
+        boolean putResult = internalCachePut(key, value);
+        if (putResult) {
+            notifyListeners(Direction.INSERT, key, value);
+        }
+        return putResult;
+    }
+    /**
+     * Implementations of QueryResultAssociativeStore can remove a key-value pair from the associative store with this method. If the
+     * removal of the key-value pair results in a change, the listeners are notified.
+     * 
+     * <p>
+     * No validation or null-checking is performed during the method!
+     * 
+     * @param key
+     *            the key which identifies where the value is removed from
+     * @param value
+     *            the value that is removed from the collection of the key
+     * @return true, if the removal resulted in a change (the key-value pair was in the associative store)
+     */
+    protected boolean internalRemove(KeyType key, ValueType value){
+        boolean removeResult = internalCacheRemove(key, value);
+        if (removeResult) {
+            notifyListeners(Direction.DELETE, key, value);
+        }
+        return removeResult;
+    }
+    
+    
+    protected abstract boolean internalCachePut(KeyType key, ValueType value);
+    protected abstract boolean internalCacheRemove(KeyType key, ValueType value);
+    protected abstract int internalCacheSize();
+    protected abstract boolean internalCacheContainsEntry(KeyType key, ValueType value);
+    
+    /**
+     * @param setter
+     *            the setter to set
+     */
+    public void setQueryResultSetter(IQueryResultSetter<KeyType, ValueType> setter) {
+        this.setter = setter;
+    }
+    
+    /**
+     * @return the logger
+     */
+    protected Logger getLogger() {
+        return logger;
+    }
+    
+    protected void internalClear() {
+        if (setter == null) {
+            throw new UnsupportedOperationException(NOT_ALLOW_MODIFICATIONS);
+        }
+        Collection<Entry<KeyType, ValueType>> entries = new ArrayList<>(getCacheEntries());
+        Iterator<Entry<KeyType, ValueType>> iterator = entries.iterator();
+        while (iterator.hasNext()) {
+            Entry<KeyType, ValueType> entry = iterator.next();
+            modifyThroughQueryResultSetter(entry.getKey(), entry.getValue(), Direction.DELETE);
+        }
+        if (internalCacheSize() != 0) {
+            StringBuilder sb = new StringBuilder();
+            for (Entry<KeyType, ValueType> entry : getCacheEntries()) {
+                if (sb.length() > 0) {
+                    sb.append(", ");
+                }
+                sb.append(entry.toString());
+            }
+            logger.warn(String
+                    .format("The query result associative store is not empty after clear, remaining entries: %s. (Developer note: %s called from QueryResultMultimap)",
+                            sb.toString(), setter));
+        }
+    }
+    
+    /**
+     * This method is used for calling the query result setter to put or remove a value by modifying the model.
+     * 
+     * <p>
+     * The given key-value pair is first validated (see {@link IQueryResultSetter#validate(Object, Object)}, then the
+     * put or remove method is called (see {@link IQueryResultSetter#put(Object, Object)} and
+     * {@link IQueryResultSetter#remove(Object, Object)}). If the setter reported that the model has been changed, the
+     * change is checked.
+     * 
+     * <p>
+     * If the model modification did not change the result set in the desired way, a warning is logged.
+     * 
+     * <p>
+     * If the setter throws any {@link Throwable}, it is either rethrown in case of {@link Error} and logged otherwise.
+     * 
+     * 
+     * @param key
+     *            the key of the pair to be inserted or removed
+     * @param value
+     *            the value of the pair to be inserted or removed
+     * @param direction
+     *            specifies whether a put or a remove is performed
+     * @return true, if the associative store changed according to the direction
+     */
+    protected boolean modifyThroughQueryResultSetter(KeyType key, ValueType value, Direction direction) {
+        try {
+            if (setter.validate(key, value)) {
+                final int size = internalCacheSize();
+                final int expectedChange = (direction == Direction.INSERT) ? 1 : -1;
+                boolean changed = false;
+                if (direction == Direction.INSERT) {
+                    changed = setter.put(key, value);
+                } else {
+                    changed = setter.remove(key, value);
+                }
+                if (changed) {
+                    return checkModificationThroughQueryResultSetter(key, value, direction, expectedChange, size);
+                } else {
+                    logger.warn(String
+                            .format("The query result associative store %s of key %s and value %s resulted in %s. (Developer note: %s called from QueryResultMultimap)",
+                                    direction == Direction.INSERT ? "insertion" : "removal", key, value,
+                                    Math.abs(internalCacheSize() - size) > 1 ? "more than one changed result"
+                                            : "no changed results", setter));
+                }
+            }
+        } catch (Exception e) { // NOPMD
+            logger.warn(
+                    String.format(
+                            "The query result associative store encountered an error during invoking setter on %s of key %s and value %s. Error message: %s. (Developer note: %s in %s called from QueryResultMultimap)",
+                            direction == Direction.INSERT ? "insertion" : "removal", key, value, e.getMessage(), e
+                                    .getClass().getSimpleName(), setter), e);
+            throw new IllegalStateException("The query result associative store encountered an error during invoking setter",e);
+        }
+        return false;
+    }
+    /**
+     * Checks whether the model modification performed by the {@link IQueryResultSetter} resulted in the insertion or
+     * removal of exactly the required key-value pair.
+     * 
+     * @param key
+     *            the key for the pair that was inserted or removed
+     * @param value
+     *            the value for the pair that was inserted or removed
+     * @param direction
+     *            the direction of the change
+     * @param size
+     *            the size of the cache before the change
+     * @return true, if the changes made by the query result setter were correct
+     */
+    protected boolean checkModificationThroughQueryResultSetter(KeyType key, ValueType value, Direction direction,
+            final int expectedChange, final int size) {
+        boolean isInsertion = direction == Direction.INSERT;
+        return (isInsertion == internalCacheContainsEntry(key, value)
+                && (internalCacheSize() - expectedChange) == size);
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultMap.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultMap.java
new file mode 100644
index 00000000..a106ea71
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/QueryResultMap.java
@@ -0,0 +1,210 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2013, Abel Hegedus, Istvan Rath 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.api;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.matchers.util.Direction;
+/**
+ * @author Abel Hegedus
+ *
+ */
+public abstract class QueryResultMap<KeyType,ValueType> extends QueryResultAssociativeStore<KeyType, ValueType> implements Map<KeyType, ValueType> {
+    /**
+     * This map contains the current key-values. Implementing classes should not modify it directly
+     */
+    private Map<KeyType, ValueType> cache;
+    
+    /**
+     * Constructor only visible to subclasses.
+     * 
+     * @param logger
+     *            a logger that can be used for error reporting
+     */
+    protected QueryResultMap(Logger logger) {
+        cache = new HashMap<KeyType, ValueType>();
+        setLogger(logger);
+    }
+    
+    @Override
+    protected Collection<java.util.Map.Entry<KeyType, ValueType>> getCacheEntries() {
+        return cache.entrySet();
+    }
+    @Override
+    protected boolean internalCachePut(KeyType key, ValueType value) {
+        ValueType put = cache.put(key, value);
+        if(put == null) {
+            return value != null;
+        } else {
+            return !put.equals(value);
+        }
+    }
+    
+    @Override
+    protected boolean internalCacheRemove(KeyType key, ValueType value) {
+        ValueType remove = cache.remove(key);
+        return remove != null;
+    }
+    @Override
+    protected int internalCacheSize() {
+        return cache.size();
+    }
+    
+    @Override
+    protected boolean internalCacheContainsEntry(KeyType key, ValueType value) {
+        return cache.containsKey(key) && cache.get(key).equals(value);
+    }
+    
+    /**
+     * @return the cache
+     */
+    protected Map<KeyType, ValueType> getCache() {
+        return cache;
+    }
+    /**
+     * @param cache
+     *            the cache to set
+     */
+    protected void setCache(Map<KeyType, ValueType> cache) {
+        this.cache = cache;
+    }
+    
+    // ======================= implemented Map methods ======================
+    @Override
+    public void clear() {
+        internalClear();
+    }
+    @Override
+    public boolean containsKey(Object key) {
+        return cache.containsKey(key);
+    }
+    @Override
+    public boolean containsValue(Object value) {
+        return cache.containsValue(value);
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * The returned set is immutable.
+     * 
+     */
+    @Override
+    public Set<Entry<KeyType, ValueType>> entrySet() {
+        return Collections.unmodifiableSet((Set<Entry<KeyType, ValueType>>) getCacheEntries());
+    }
+    @Override
+    public ValueType get(Object key) {
+        return cache.get(key);
+    }
+    @Override
+    public boolean isEmpty() {
+        return cache.isEmpty();
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * The returned set is immutable.
+     * 
+     */
+    @Override
+    public Set<KeyType> keySet() {
+        return Collections.unmodifiableSet(cache.keySet());
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * Throws {@link UnsupportedOperationException} if there is no {@link IQueryResultSetter}
+     */
+    @Override
+    public ValueType put(KeyType key, ValueType value) {
+        if (getSetter() == null) {
+            throw new UnsupportedOperationException(NOT_ALLOW_MODIFICATIONS);
+        }
+        ValueType oldValue = cache.get(key);
+        boolean modified = modifyThroughQueryResultSetter(key, value, Direction.INSERT);
+        return modified ? oldValue : null;
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * Throws {@link UnsupportedOperationException} if there is no {@link IQueryResultSetter}
+     */
+    @Override
+    public void putAll(Map<? extends KeyType, ? extends ValueType> map) {
+        if (getSetter() == null) {
+            throw new UnsupportedOperationException(NOT_ALLOW_MODIFICATIONS);
+        }
+        for (Entry<? extends KeyType, ? extends ValueType> entry : map.entrySet()) {
+            modifyThroughQueryResultSetter(entry.getKey(), entry.getValue(), Direction.INSERT);
+        }
+        return;
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * Throws {@link UnsupportedOperationException} if there is no {@link IQueryResultSetter}
+     */
+    @SuppressWarnings("unchecked")
+    @Override
+    public ValueType remove(Object key) {
+        if (getSetter() == null) {
+            throw new UnsupportedOperationException(NOT_ALLOW_MODIFICATIONS);
+        }
+        // if it contains the entry, the types MUST be correct
+        if (cache.containsKey(key)) {
+            ValueType value = cache.get(key);
+            modifyThroughQueryResultSetter((KeyType) key, value, Direction.DELETE);
+            return value;
+        }
+        return null;
+    }
+    @Override
+    public int size() {
+        return internalCacheSize();
+    }
+    /**
+     * {@inheritDoc}
+     * 
+     * <p>
+     * The returned collection is immutable.
+     * 
+     */
+    @Override
+    public Collection<ValueType> values() {
+        return Collections.unmodifiableCollection(cache.values());
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/TransitiveClosureHelper.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/TransitiveClosureHelper.java
new file mode 100644
index 00000000..fc92fef3
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/TransitiveClosureHelper.java
@@ -0,0 +1,26 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import org.eclipse.emf.ecore.EObject;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcDataSource;
+/**
+ * The class can be used to compute the transitive closure of a given emf model, where the nodes will be the objects in
+ * the model and the edges will be represented by the references between them. One must provide the set of references
+ * that the helper should treat as edges when creating an instance with the factory: only the notifications about these
+ * references will be handled.
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public interface TransitiveClosureHelper extends ITcDataSource<EObject> {
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/ViatraBaseFactory.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/ViatraBaseFactory.java
new file mode 100644
index 00000000..81bd4f35
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/ViatraBaseFactory.java
@@ -0,0 +1,180 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.api;
+import java.util.Set;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperImpl;
+import tools.refinery.viatra.runtime.base.core.TransitiveClosureHelperImpl;
+/**
+ * Factory class for the utils in the library: <ul>
+ * <li>NavigationHelper (automatic and manual) 
+ * <li>TransitiveClosureUtil
+ * </ul>
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public class ViatraBaseFactory {
+    private static ViatraBaseFactory instance;
+    /**
+     * Get the singleton instance of ViatraBaseFactory.
+     * 
+     * @return the singleton instance
+     */
+    public static synchronized ViatraBaseFactory getInstance() {
+        if (instance == null) {
+            instance = new ViatraBaseFactory();
+        }
+        return instance;
+    }
+    protected ViatraBaseFactory() {
+        super();
+    }
+    /**
+     * The method creates a {@link NavigationHelper} index for the given EMF model root. 
+     * A new instance will be created on every call.
+     * <p>
+     * A NavigationHelper in wildcard mode will process and index all EStructuralFeatures, EClasses and EDatatypes. If
+     * wildcard mode is off, the client will have to manually register the interesting aspects of the model.
+     * <p>
+     * The NavigationHelper will be created without dynamic EMF support by default. 
+     * See {@link #createNavigationHelper(Notifier, boolean, boolean, Logger)} for more options.
+     * 
+     * @see NavigationHelper
+     * 
+     * @param emfRoot
+     *            the root of the EMF tree to be indexed. Recommended: Resource or ResourceSet. Can be null - you can
+     *            add a root later using {@link NavigationHelper#addRoot(Notifier)}
+     * @param wildcardMode
+     *            true if all aspects of the EMF model should be indexed automatically, false if manual registration of
+     *            interesting aspects is desirable
+     * @param logger
+     *            the log output where errors will be logged if encountered during the operation of the
+     *            NavigationHelper; if null, the default logger for {@link NavigationHelper} is used.
+     * @return the NavigationHelper instance
+     * @throws ViatraQueryRuntimeException
+     */
+    public NavigationHelper createNavigationHelper(Notifier emfRoot, boolean wildcardMode, Logger logger) {
+        BaseIndexOptions options = new BaseIndexOptions(false, wildcardMode ? IndexingLevel.FULL : IndexingLevel.NONE);
+        return createNavigationHelper(emfRoot, options, logger);
+    }
+    
+    /**
+     * The method creates a {@link NavigationHelper} index for the given EMF model root.
+     * A new instance will be created on every call.
+     * <p>
+     * A NavigationHelper in wildcard mode will process and index all EStructuralFeatures, EClasses and EDatatypes. If
+     * wildcard mode is off, the client will have to manually register the interesting aspects of the model.
+     * <p>
+     * If the dynamic model flag is set to true, the index will use String ids to distinguish between the various 
+     * {@link EStructuralFeature}, {@link EClass} and {@link EDataType} instances. This way the index is able to 
+     * handle dynamic EMF instance models too. 
+     * 
+     * @see NavigationHelper
+     * 
+     * @param emfRoot
+     *            the root of the EMF tree to be indexed. Recommended: Resource or ResourceSet. Can be null - you can
+     *            add a root later using {@link NavigationHelper#addRoot(Notifier)}
+     * @param wildcardMode
+     *            true if all aspects of the EMF model should be indexed automatically, false if manual registration of
+     *            interesting aspects is desirable
+     * @param dynamicModel
+     *            true if the index should use String ids (nsURIs) for the various EMF types and features, and treat  
+     *            multiple EPackages sharing an nsURI as the same. false if dynamic model support is not required
+     * @param logger
+     *            the log output where errors will be logged if encountered during the operation of the
+     *            NavigationHelper; if null, the default logger for {@link NavigationHelper} is used.
+     * @return the NavigationHelper instance
+     * @throws ViatraQueryRuntimeException
+     */
+    public NavigationHelper createNavigationHelper(Notifier emfRoot, boolean wildcardMode, boolean dynamicModel, Logger logger) {
+        BaseIndexOptions options = new BaseIndexOptions(dynamicModel, wildcardMode ? IndexingLevel.FULL : IndexingLevel.NONE);
+        return createNavigationHelper(emfRoot, options, logger);
+    }
+    
+    /**
+     * The method creates a {@link NavigationHelper} index for the given EMF model root.
+     * A new instance will be created on every call.
+     * <p>
+     * For details of base index options including wildcard and dynamic EMF mode, see {@link BaseIndexOptions}.
+     *
+     * @see NavigationHelper
+     * 
+     * @param emfRoot
+     *            the root of the EMF tree to be indexed. Recommended: Resource or ResourceSet. Can be null - you can
+     *            add a root later using {@link NavigationHelper#addRoot(Notifier)}
+     * @param options the options used by the index 
+     * @param logger
+     *            the log output where errors will be logged if encountered during the operation of the
+     *            NavigationHelper; if null, the default logger for {@link NavigationHelper} is used.
+     * @return the NavigationHelper instance
+     * @throws ViatraQueryRuntimeException
+     */
+    public NavigationHelper createNavigationHelper(Notifier emfRoot, BaseIndexOptions options, Logger logger) {
+        Logger l = logger;
+        if (l == null)
+            l = Logger.getLogger(NavigationHelper.class);
+        return new NavigationHelperImpl(emfRoot, options, l);
+    }
+    
+    
+    /**
+     * The method creates a TransitiveClosureHelper instance for the given EMF model root.
+     * A new instance will be created on every call.
+     * 
+     * <p>
+     * One must specify the set of EReferences that will be considered as edges. The set can contain multiple elements;
+     * this way one can query forward and backward reachability information along heterogenous paths.
+     * 
+     * @param emfRoot
+     *            the root of the EMF tree to be processed. Recommended: Resource or ResourceSet.
+     * @param referencesToObserve
+     *            the set of references to observe
+     * @return the TransitiveClosureHelper instance
+     * @throws ViatraQueryRuntimeException if the creation of the internal NavigationHelper failed
+     */
+    public TransitiveClosureHelper createTransitiveClosureHelper(Notifier emfRoot, Set<EReference> referencesToObserve) {
+        return new TransitiveClosureHelperImpl(getInstance().createNavigationHelper(emfRoot, false, null), true, referencesToObserve);
+    }
+    /**
+     * The method creates a TransitiveClosureHelper instance built on an existing NavigationHelper.
+     * A new instance will be created on every call.
+     * 
+     * <p>
+     * One must specify the set of EReferences that will be considered as edges. The set can contain multiple elements;
+     * this way one can query forward and backward reachability information along heterogenous paths.
+     * 
+     * @param baseIndex
+     *            the already existing NavigationHelper index on the model
+     * @param referencesToObserve
+     *            the set of references to observe
+     * @return the TransitiveClosureHelper instance
+     */
+    public TransitiveClosureHelper createTransitiveClosureHelper(NavigationHelper baseIndex, Set<EReference> referencesToObserve) {
+        return new TransitiveClosureHelperImpl(baseIndex, false, referencesToObserve);
+    }
+    
+    
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexFeatureFilter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexFeatureFilter.java
new file mode 100644
index 00000000..8929b2ab
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexFeatureFilter.java
@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2010-2016, Peter Lunk, IncQuery Labs Ltd.
+ * 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.api.filters;
+import org.eclipse.emf.ecore.EStructuralFeature;
+/**
+ * 
+ * Defines if an {@link EStructuralFeature} should not be indexed by VIATRA Base. This filtering 
+ * method should only be used if the input metamodel has certain features, that the base indexer 
+ * cannot handle. If the filtered feature is a containment feature, the whole sub-tree accessible 
+ * through the said feature will be filtered.
+ *
+ * Note: This API feature is for advanced users only. Usage of this feature is not encouraged, 
+ * unless the filtering task is impossible via using the more straightforward 
+ * {@link IBaseIndexResourceFilter} or {@link IBaseIndexObjectFilter}.   
+ * 
+ * @author Peter Lunk
+ * @since 1.5
+ * 
+ */
+public interface IBaseIndexFeatureFilter {
+    /**
+     * Decides whether the selected {@link EStructuralFeature} is filtered.
+     * 
+     * @param feature
+     * @return true, if the feature should not be indexed
+     */
+    boolean isFiltered(EStructuralFeature feature);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexObjectFilter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexObjectFilter.java
new file mode 100644
index 00000000..e1e46bbd
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexObjectFilter.java
@@ -0,0 +1,30 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath 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.api.filters;
+import org.eclipse.emf.common.notify.Notifier;
+/**
+ * 
+ * Stores a collection of {@link Notifier} instances that need not to be indexed by VIATRA Base.
+ * 
+ * @author Zoltan Ujhelyi
+ * 
+ */
+public interface IBaseIndexObjectFilter {
+    /**
+     * Decides whether the selected notifier is filtered.
+     * 
+     * @param notifier
+     * @return true, if the notifier should not be indexed
+     */
+    boolean isFiltered(Notifier notifier);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexResourceFilter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexResourceFilter.java
new file mode 100644
index 00000000..73d3e961
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/IBaseIndexResourceFilter.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath 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.api.filters;
+import org.eclipse.emf.ecore.resource.Resource;
+/**
+ * Defines a filter for indexing resources
+ * @author Zoltan Ujhelyi
+ *
+ */
+public interface IBaseIndexResourceFilter {
+    /**
+     * Decides whether a selected resource needs to be indexed
+     * @param resource
+     * @return true, if the selected resource is filtered
+     */
+    boolean isResourceFiltered(Resource resource);
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/SimpleBaseIndexFilter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/SimpleBaseIndexFilter.java
new file mode 100644
index 00000000..9ae88a1a
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/filters/SimpleBaseIndexFilter.java
@@ -0,0 +1,46 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2014, Zoltan Ujhelyi, Istvan Rath 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.api.filters;
+import org.eclipse.emf.common.notify.Notifier;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+/**
+ * An index filter that is based on a collection of {@link Notifier} instances.
+ *
+ * @author Zoltan Ujhelyi
+ *
+ */
+public class SimpleBaseIndexFilter implements IBaseIndexObjectFilter {
+    Set<Notifier> filters;
+    /**
+     * Creates a filter using a collection of (Resource and) Notifier instances. Every containment subtree, selected by
+     * the given Notifiers are filtered out.
+     *
+     * @param filterConfiguration
+     */
+    public SimpleBaseIndexFilter(Collection<Notifier> filterConfiguration) {
+        filters = new HashSet<>(filterConfiguration);
+    }
+    public SimpleBaseIndexFilter(SimpleBaseIndexFilter other) {
+        this(other.filters);
+    }
+    @Override
+    public boolean isFiltered(Notifier notifier) {
+        return filters.contains(notifier);
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/BaseIndexProfiler.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/BaseIndexProfiler.java
new file mode 100644
index 00000000..d3cc152e
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/BaseIndexProfiler.java
@@ -0,0 +1,79 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * 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.api.profiler;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperContentAdapter;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperImpl;
+import tools.refinery.viatra.runtime.base.core.profiler.ProfilingNavigationHelperContentAdapter;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+/**
+ * An index profiler can be attached to an existing navigation helper instance to access the profiling data and control
+ * the profiler itself. If the NavigationHelper was not started in profiling mode, the profiler cannot be initialized.
+ * 
+ * @since 2.3
+ */
+public class BaseIndexProfiler {
+    ProfilingNavigationHelperContentAdapter adapter;
+    
+    /**
+     * 
+     * @throws IllegalArgumentException if the profiler cannot be attached to the base index instance
+     */
+    public BaseIndexProfiler(NavigationHelper navigationHelper) {
+        if (navigationHelper instanceof NavigationHelperImpl) {
+            final NavigationHelperContentAdapter contentAdapter = ((NavigationHelperImpl) navigationHelper).getContentAdapter();
+            if (contentAdapter instanceof ProfilingNavigationHelperContentAdapter) {
+                adapter = (ProfilingNavigationHelperContentAdapter)contentAdapter;
+            }
+        }
+        Preconditions.checkArgument(adapter != null, "Cannot attach profiler to Base Index");
+    }
+    /**
+     * Returns the number of external request (e.g. model changes) the profiler recorded. 
+     */
+    public long getNotificationCount() {
+        return adapter.getNotificationCount();
+    }
+    /**
+     * Return the total time base index profiler recorded for reacting to model operations. 
+     */
+    public long getTotalMeasuredTimeInMS() {
+        return adapter.getTotalMeasuredTimeInMS();
+    }
+    /**
+     * Returns whether the profiler is turned on (e.g. measured values are increased).
+     */
+    public boolean isEnabled() {
+        return adapter.isEnabled();
+    }
+    /**
+     * Enables the base index profiling (e.g. measured values are increased)
+     */
+    public void setEnabled(boolean isEnabled) {
+        adapter.setEnabled(isEnabled);
+    }
+    /**
+     * Resets all measurements to 0, regardless whether the profiler is enabled or not.
+     * </p>
+     * 
+     * <strong>Note</strong>: The behavior of the profiler is undefined when the measurements are reset while an EMF
+     * notification is being processed and the profiler is enabled.
+     */
+    public void resetMeasurement() {
+        adapter.resetMeasurement();
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/ProfilerMode.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/ProfilerMode.java
new file mode 100644
index 00000000..74901263
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/api/profiler/ProfilerMode.java
@@ -0,0 +1,22 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * 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.api.profiler;
+/**
+ * @since 2.3
+ */
+public enum ProfilerMode {
+    /** The base index profiler is not available */
+    OFF,
+    /** The profiler is initialized but not started until necessary */ 
+    START_DISABLED,
+    /** The profiler is initialized and started by default */
+    START_ENABLED
+}
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
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFVisitor.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFVisitor.java
new file mode 100644
index 00000000..6029bb02
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/EMFVisitor.java
@@ -0,0 +1,145 @@
+/*******************************************************************************
+ * 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 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.resource.Resource;
+/**
+ * Use EMFModelComprehension to visit an EMF model.
+ * 
+ * @author Bergmann Gábor
+ * 
+ */
+// FIXME:
+// - handle boundary of active emfRoot subtree
+// - more efficient traversal
+public class EMFVisitor {
+    boolean preOrder;
+    public EMFVisitor(boolean preOrder) {
+        super();
+        this.preOrder = preOrder;
+    }
+    /**
+     * @param resource
+     * @param element
+     */
+    public void visitTopElementInResource(Resource resource, EObject element) {
+    }
+    /**
+     * @param resource
+     */
+    public void visitResource(Resource resource) {
+    }
+    /**
+     * @param source
+     */
+    public void visitElement(EObject source) {
+    }
+    /**
+     * @param source
+     * @param feature
+     * @param target
+     */
+    public void visitNonContainmentReference(EObject source, EReference feature, EObject target) {
+    }
+    /**
+     * @param source
+     * @param feature
+     * @param target
+     */
+    public void visitInternalContainment(EObject source, EReference feature, EObject target) {
+    }
+    /**
+     * @param source
+     * @param feature
+     * @param target
+     */
+    public void visitAttribute(EObject source, EAttribute feature, Object target) {
+    }
+    /**
+     * Returns true if the given feature should not be traversed (interesting esp. if multi-valued)
+     */
+    public boolean pruneFeature(EStructuralFeature feature) {
+        return false;
+    }
+    /**
+     * Returns true if the contents of an object should be pruned (and not explored by the visitor)
+     */
+    public boolean pruneSubtrees(EObject source) {
+        return false;
+    }
+    /**
+     * Returns true if the contents of a resource should be pruned (and not explored by the visitor)
+     */
+    public boolean pruneSubtrees(Resource source) {
+        return false;
+    }
+    /**
+     * An opportunity for the visitor to indicate that the containment link is considered in a transient state, and the
+     * model comprehension should avoid following it.
+     * 
+     * A containment is in a transient state from the point of view of the visitor if it connects a subtree that is
+     * being inserted <em>during</em> a full-model traversal, and a separate notification handler will deal with it
+     * later.
+     */
+    public boolean avoidTransientContainmentLink(EObject source, EReference reference, EObject targetObject) {
+        return false;
+    }
+    /**
+     * @return if objects should be visited before their outgoing edges
+     */
+    public boolean preOrder() {
+        return preOrder;
+    }
+    /**
+     * Called after visiting the reference, if the target is a proxy.
+     * 
+     * @param position
+     *            optional: known position in multivalued collection (for more efficient proxy resolution)
+     */
+    public void visitProxyReference(EObject source, EReference reference, EObject targetObject, Integer position) {
+    }
+    /**
+     * Whether the given reference of the given object should be resolved when it is a proxy 
+     */
+    public boolean attemptProxyResolutions(EObject source, EReference feature) {
+        return true;
+    }
+    /**
+     * @return true if traversing visitors shall descend along cross-resource containments
+     * (this only makes sense for traversing visitors on an object scope)
+     * 
+     * @since 1.7
+     */
+    public boolean descendAlongCrossResourceContainments() {
+        return false;
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/WellbehavingDerivedFeatureRegistry.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/WellbehavingDerivedFeatureRegistry.java
new file mode 100644
index 00000000..d696ddd6
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/comprehension/WellbehavingDerivedFeatureRegistry.java
@@ -0,0 +1,154 @@
+/*******************************************************************************
+ * Copyright (c) 2004-2011 Abel Hegedus 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.Collection;
+import java.util.Collections;
+import java.util.WeakHashMap;
+import org.apache.log4j.Logger;
+import org.eclipse.core.runtime.IConfigurationElement;
+import org.eclipse.core.runtime.IExtension;
+import org.eclipse.core.runtime.IExtensionPoint;
+import org.eclipse.core.runtime.IExtensionRegistry;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import tools.refinery.viatra.runtime.base.ViatraBasePlugin;
+/**
+ * @author Abel Hegedus
+ * 
+ */
+public class WellbehavingDerivedFeatureRegistry {
+    
+    private static Collection<EStructuralFeature> contributedWellbehavingDerivedFeatures = Collections.newSetFromMap(new WeakHashMap<EStructuralFeature, Boolean>());
+    private static Collection<EClass> contributedWellbehavingDerivedClasses = Collections.newSetFromMap(new WeakHashMap<EClass, Boolean>());
+    private static Collection<EPackage> contributedWellbehavingDerivedPackages = Collections.newSetFromMap(new WeakHashMap<EPackage, Boolean>());
+    private WellbehavingDerivedFeatureRegistry() {
+    }
+    /**
+     * Called by ViatraBasePlugin.
+     */
+    public static void initRegistry() {
+        getContributedWellbehavingDerivedFeatures().clear();
+        getContributedWellbehavingDerivedClasses().clear();
+        getContributedWellbehavingDerivedPackages().clear();
+        IExtensionRegistry reg = Platform.getExtensionRegistry();
+        IExtensionPoint poi;
+        poi = reg.getExtensionPoint(ViatraBasePlugin.WELLBEHAVING_DERIVED_FEATURE_EXTENSION_POINT_ID);
+        if (poi != null) {
+            IExtension[] exts = poi.getExtensions();
+            for (IExtension ext : exts) {
+                IConfigurationElement[] els = ext.getConfigurationElements();
+                for (IConfigurationElement el : els) {
+                    if (el.getName().equals("wellbehaving-derived-feature")) {
+                        processWellbehavingExtension(el);
+                    } else {
+                        throw new UnsupportedOperationException("Unknown configuration element " + el.getName()
+                                + " in plugin.xml of " + el.getDeclaringExtension().getUniqueIdentifier());
+                    }
+                }
+            }
+        }
+    }
+    private static void processWellbehavingExtension(IConfigurationElement el) {
+        try {
+            String packageUri = el.getAttribute("package-nsUri");
+            String featureName = el.getAttribute("feature-name");
+            String classifierName = el.getAttribute("classifier-name");
+            String contributorName = el.getContributor().getName();
+            StringBuilder featureIdBuilder = new StringBuilder();
+            if (packageUri != null) {
+                EPackage pckg = EPackage.Registry.INSTANCE.getEPackage(packageUri);
+                featureIdBuilder.append(packageUri);
+                if (pckg != null) {
+                    if (classifierName != null) {
+                        EClassifier clsr = pckg.getEClassifier(classifierName);
+                        featureIdBuilder.append("##").append(classifierName);
+                        if (clsr instanceof EClass) {
+                            if (featureName != null) {
+                                EClass cls = (EClass) clsr;
+                                EStructuralFeature feature = cls.getEStructuralFeature(featureName);
+                                featureIdBuilder.append("##").append(featureName);
+                                if (feature != null) {
+                                    registerWellbehavingDerivedFeature(feature);
+                                } else {
+                                    throw new IllegalStateException(String.format("Feature %s of EClass %s in package %s not found! (plug-in %s)", featureName, classifierName, packageUri, contributorName));
+                                }
+                            } else {
+                                registerWellbehavingDerivedClass((EClass) clsr);
+                            }
+                        } else {
+                            throw new IllegalStateException(String.format("EClassifier %s does not exist in package %s! (plug-in %s)", classifierName, packageUri, contributorName));
+                        }
+                    } else {
+                        if(featureName != null){
+                            throw new IllegalStateException(String.format("Feature name must be empty if classifier name is not set! (package %s, plug-in %s)", packageUri, contributorName));
+                        }
+                        registerWellbehavingDerivedPackage(pckg);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            final Logger logger = Logger.getLogger(WellbehavingDerivedFeatureRegistry.class);
+            logger.error("Well-behaving feature registration failed", e);
+        }
+    }
+    /**
+     * 
+     * @param feature
+     * @return true if the feature (or its defining EClass or ) is registered as well-behaving
+     */
+    public static boolean isWellbehavingFeature(EStructuralFeature feature) {
+        if(feature == null){
+            return false;
+        } else if (contributedWellbehavingDerivedFeatures.contains(feature)) {
+            return true;
+        } else if (contributedWellbehavingDerivedClasses.contains(feature.getEContainingClass())) {
+            return true;
+        } else return contributedWellbehavingDerivedPackages.contains(feature.getEContainingClass().getEPackage());
+    }
+    public static void registerWellbehavingDerivedFeature(EStructuralFeature feature) {
+        contributedWellbehavingDerivedFeatures.add(feature);
+    }
+    public static void registerWellbehavingDerivedClass(EClass cls) {
+        contributedWellbehavingDerivedClasses.add(cls);
+    }
+    public static void registerWellbehavingDerivedPackage(EPackage pkg) {
+        contributedWellbehavingDerivedPackages.add(pkg);
+    }
+    public static Collection<EStructuralFeature> getContributedWellbehavingDerivedFeatures() {
+        return contributedWellbehavingDerivedFeatures;
+    }
+    public static Collection<EClass> getContributedWellbehavingDerivedClasses() {
+        return contributedWellbehavingDerivedClasses;
+    }
+    public static Collection<EPackage> getContributedWellbehavingDerivedPackages() {
+        return contributedWellbehavingDerivedPackages;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/AbstractBaseIndexStore.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/AbstractBaseIndexStore.java
new file mode 100644
index 00000000..3d61b1bf
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/AbstractBaseIndexStore.java
@@ -0,0 +1,28 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2017, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * 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.core;
+import org.apache.log4j.Logger;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+/**
+ * @since 1.6
+ */
+public class AbstractBaseIndexStore {
+    protected final NavigationHelperImpl navigationHelper;
+    protected final Logger logger;
+    protected final BaseIndexOptions options;
+    
+    public AbstractBaseIndexStore(NavigationHelperImpl navigationHelper, Logger logger) {
+        this.navigationHelper = navigationHelper;
+        this.logger = logger;
+        this.options = navigationHelper.getBaseIndexOptions();
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexInstanceStore.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexInstanceStore.java
new file mode 100644
index 00000000..2094bbbe
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexInstanceStore.java
@@ -0,0 +1,451 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, Istvan Rath 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.core;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EObject;
+import tools.refinery.viatra.runtime.base.api.IStructuralFeatureInstanceProcessor;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.IMultiset;
+/**
+ * Stores the indexed contents of an EMF model 
+ *      (includes instance model information).
+ * 
+ * @author Gabor Bergmann
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class EMFBaseIndexInstanceStore extends AbstractBaseIndexStore {
+    
+    public EMFBaseIndexInstanceStore(NavigationHelperImpl navigationHelper, Logger logger) {
+        super(navigationHelper, logger);
+    }
+    /**
+     * since last run of after-update callbacks
+     */
+    boolean isDirty = false;
+    
+    /**
+     * feature (EAttribute or EReference or equivalent String key) -> FeatureData
+     * @since 1.7
+     */
+    private Map<Object, FeatureData> featureDataMap = CollectionsFactory.createMap();
+    
+    /**
+     * value -> featureKey(s);
+     * constructed on-demand, null if unused (hopefully most of the time)
+     */
+    private Map<Object, IMultiset<Object>> valueToFeatureMap = null; 
+    
+    /**
+     * key (String id or EClass instance) -> instance(s)
+     */
+    private final Map<Object, Set<EObject>> instanceMap = CollectionsFactory.createMap();
+    /**
+     * key (String id or EDataType instance) -> multiset of value(s)
+     */
+    private final Map<Object, IMultiset<Object>> dataTypeMap = CollectionsFactory.createMap();
+    
+    /**
+     * Bundles all instance store data specific to a given binary feature.
+     * 
+     * <p> TODO: specialize for to-one features and unique to-many features
+     * <p> TODO: on-demand construction of valueToHolderMap
+     * 
+     * @author Gabor Bergmann
+     * @since 1.7
+     */
+    class FeatureData {
+        /** value -> holder(s) */
+        private Map<Object, IMultiset<EObject>> valueToHolderMap = CollectionsFactory.createMap(); 
+        /**
+         * holder -> value(s);
+         * constructed on-demand, null if unused
+         */
+        private Map<EObject, IMultiset<Object>> holderToValueMap; 
+               
+        /**
+         * feature (EAttribute or EReference) or its string key (in dynamic EMF mode)
+         */
+        private Object featureKey;
+        
+        /**
+         * @return feature (EAttribute or EReference) or its string key (in dynamic EMF mode)
+         */
+       public Object getFeatureKey() {
+            return featureKey;
+        }
+        
+        @Override
+        public String toString() {
+            return this.getClass().getSimpleName() + ":" + featureKey;
+        }
+        /**
+         * @return true if this was the first time the value was added to this feature of this holder (false is only
+         *         expected for non-unique features)
+         */
+        boolean insertFeatureTuple(boolean unique, final Object value, final EObject holder) {
+            // TODO we currently assume V2H map exists
+           boolean changed = addToValueToHolderMap(value, holder);
+            if (holderToValueMap != null) {
+                addToHolderToValueMap(value, holder);
+            }
+            
+            if (unique && !changed) { 
+                navigationHelper.logIncidentFeatureTupleInsertion(value, holder, featureKey);
+            }
+            return changed;
+        }
+        /**
+         * @return true if this was the last duplicate of the value added to this feature of this holder (false is only
+         *         expected for non-unique features)
+         */
+        boolean removeFeatureTuple(boolean unique, final Object value, final EObject holder) {
+            Object featureKey = getFeatureKey();
+            try {
+                // TODO we currently assume V2H map exists
+                boolean changed = removeFromValueToHolderMap(value, holder);
+                if (holderToValueMap != null) {
+                    removeFromHolderToValueMap(value, holder);
+                }
+                
+                if (unique && !changed) { 
+                    navigationHelper.logIncidentFeatureTupleRemoval(value, holder, featureKey);
+                }
+                return changed;
+            } catch (IllegalStateException ex) {
+                navigationHelper.logIncidentFeatureTupleRemoval(value, holder, featureKey);
+                return false;
+            }
+        }
+        protected boolean addToHolderToValueMap(Object value, EObject holder) {
+            IMultiset<Object> values = holderToValueMap.computeIfAbsent(holder, 
+                    CollectionsFactory::emptyMultiset);
+            boolean changed = values.addOne(value);
+            return changed;
+        }
+        
+        protected boolean addToValueToHolderMap(final Object value, final EObject holder) {
+            IMultiset<EObject> holders = valueToHolderMap.computeIfAbsent(value, 
+                    CollectionsFactory::emptyMultiset);
+            boolean changed = holders.addOne(holder);
+            return changed;
+        }
+        
+        protected boolean removeFromHolderToValueMap(Object value, EObject holder) throws IllegalStateException {
+            IMultiset<Object> values = holderToValueMap.get(holder);
+            if (values == null)
+                throw new IllegalStateException();
+            boolean changed = values.removeOne(value);
+            if (changed && values.isEmpty())
+                holderToValueMap.remove(holder);
+            return changed;
+        }
+        protected boolean removeFromValueToHolderMap(final Object value, final EObject holder) throws IllegalStateException {
+            IMultiset<EObject> holders = valueToHolderMap.get(value);
+            if (holders == null)
+                throw new IllegalStateException();
+            boolean changed = holders.removeOne(holder);
+            if (changed && holders.isEmpty())
+                valueToHolderMap.remove(value);
+            return changed;
+        }
+        protected Map<EObject, IMultiset<Object>> getHolderToValueMap() {
+            if (holderToValueMap == null) {
+                holderToValueMap = CollectionsFactory.createMap();
+                
+                // TODO we currently assume V2H map exists
+                for (Entry<Object, IMultiset<EObject>> entry : valueToHolderMap.entrySet()) {
+                    Object value = entry.getKey();
+                    IMultiset<EObject> holders = entry.getValue();
+                    for (EObject holder : holders.distinctValues()) {
+                        int count = holders.getCount(holder);
+                        
+                        IMultiset<Object> valuesOfHolder = holderToValueMap.computeIfAbsent(holder,
+                                CollectionsFactory::emptyMultiset);
+                        valuesOfHolder.addPositive(value, count);
+                    }
+                }
+            }
+            return holderToValueMap;
+        }        
+        protected Map<Object, IMultiset<EObject>> getValueToHolderMap() {
+            // TODO we currently assume V2H map exists
+            return valueToHolderMap;
+        }
+        
+        public void forEach(IStructuralFeatureInstanceProcessor processor) {
+            // TODO we currently assume V2H map exists
+            if (valueToHolderMap != null) {
+                for (Entry<Object, IMultiset<EObject>> entry : valueToHolderMap.entrySet()) {
+                    Object value = entry.getKey();
+                    for (EObject eObject : entry.getValue().distinctValues()) {
+                        processor.process(eObject, value);
+                    }
+                }
+            } else throw new UnsupportedOperationException("TODO implement");
+        }
+        
+        public Set<EObject> getAllDistinctHolders() {
+            return getHolderToValueMap().keySet();
+        }
+        public Set<Object> getAllDistinctValues() {
+            return getValueToHolderMap().keySet();
+        }
+        public Set<EObject> getDistinctHoldersOfValue(Object value) {
+            IMultiset<EObject> holdersMultiset = getValueToHolderMap().get(value);
+            if (holdersMultiset == null) 
+                return Collections.emptySet();
+            else return holdersMultiset.distinctValues();
+        }
+        public Set<Object> getDistinctValuesOfHolder(EObject holder) {
+            IMultiset<Object> valuesMultiset = getHolderToValueMap().get(holder);
+            if (valuesMultiset == null) 
+                return Collections.emptySet();
+            else return valuesMultiset.distinctValues();
+        }
+        public boolean isInstance(EObject source, Object target) {
+            // TODO we currently assume V2H map exists
+           if (valueToHolderMap != null) {
+                IMultiset<EObject> holders = valueToHolderMap.get(target);
+                return holders != null && holders.containsNonZero(source);
+           } else throw new UnsupportedOperationException("TODO implement");
+        }
+        
+    }
+    
+    
+    FeatureData getFeatureData(Object featureKey) {
+        FeatureData data = featureDataMap.get(featureKey);
+        if (data == null) {
+            data = createFeatureData(featureKey);
+            featureDataMap.put(featureKey, data);
+        }
+        return data;
+    }
+    /**
+     * TODO: specialize for to-one features and unique to-many features
+     */
+    protected FeatureData createFeatureData(Object featureKey) {
+        FeatureData data = new FeatureData();
+        data.featureKey = featureKey;
+        return data;
+    }
+    protected void insertFeatureTuple(final Object featureKey, boolean unique, final Object value, final EObject holder) {
+        boolean changed = getFeatureData(featureKey).insertFeatureTuple(unique, value, holder);
+        if (changed) { // if not duplicated
+            
+            if (valueToFeatureMap != null) {
+                insertIntoValueToFeatureMap(featureKey, value);
+            }
+            
+            isDirty = true;
+            navigationHelper.notifyFeatureListeners(holder, featureKey, value, true);
+        }
+    }
+    protected void removeFeatureTuple(final Object featureKey, boolean unique, final Object value, final EObject holder) {
+        boolean changed = getFeatureData(featureKey).removeFeatureTuple(unique, value, holder);
+        if (changed) { // if not duplicated
+            
+            if (valueToFeatureMap != null) {
+                removeFromValueToFeatureMap(featureKey, value);
+            }
+            
+            isDirty = true;
+            navigationHelper.notifyFeatureListeners(holder, featureKey, value, false);
+        }
+    }
+    
+    public Set<Object> getFeatureKeysPointingTo(Object target) {
+        final IMultiset<Object> sources = getValueToFeatureMap().get(target);
+        return sources == null ? Collections.emptySet() : sources.distinctValues();
+    }
+    
+    protected Map<Object, IMultiset<Object>> getValueToFeatureMap() {
+        if (valueToFeatureMap == null) { // must be inverted from feature data
+            valueToFeatureMap = CollectionsFactory.createMap();
+            for (FeatureData featureData : featureDataMap.values()) {
+                final Object featureKey = featureData.getFeatureKey();
+                featureData.forEach((source, target) -> insertIntoValueToFeatureMap(featureKey, target));
+            }
+        }
+        return valueToFeatureMap;
+    }
+    
+    protected void insertIntoValueToFeatureMap(final Object featureKey, Object target) {
+        IMultiset<Object> featureKeys = valueToFeatureMap.computeIfAbsent(target, CollectionsFactory::emptyMultiset);
+        featureKeys.addOne(featureKey);
+    }
+    protected void removeFromValueToFeatureMap(final Object featureKey, final Object value) {
+        IMultiset<Object> featureKeys = valueToFeatureMap.get(value);
+        if (featureKeys == null) 
+            throw new IllegalStateException();
+        featureKeys.removeOne(featureKey);
+        if (featureKeys.isEmpty()) 
+            valueToFeatureMap.remove(value);
+    }
+    // START ********* InstanceSet *********
+    public Set<EObject> getInstanceSet(final Object keyClass) {
+        return instanceMap.get(keyClass);
+    }
+    public void removeInstanceSet(final Object keyClass) {
+        instanceMap.remove(keyClass);
+    }
+    public void insertIntoInstanceSet(final Object keyClass, final EObject value) {
+        Set<EObject> set = instanceMap.computeIfAbsent(keyClass, CollectionsFactory::emptySet);
+        
+        if (!set.add(value)) {
+            navigationHelper.logIncidentInstanceInsertion(keyClass, value);
+        } else {
+            isDirty = true;
+            navigationHelper.notifyInstanceListeners(keyClass, value, true);
+        }
+    }
+    public void removeFromInstanceSet(final Object keyClass, final EObject value) {
+        final Set<EObject> set = instanceMap.get(keyClass);
+        if (set != null) {
+            if(!set.remove(value)) {
+                navigationHelper.logIncidentInstanceRemoval(keyClass, value);
+            } else {
+                if (set.isEmpty()) {
+                    instanceMap.remove(keyClass);
+                }
+                isDirty = true;
+                navigationHelper.notifyInstanceListeners(keyClass, value, false);
+            }
+        } else {
+            navigationHelper.logIncidentInstanceRemoval(keyClass, value);
+        }
+    }
+    
+    // END ********* InstanceSet *********
+    // START ********* DataTypeMap *********
+    public Set<Object> getDistinctDataTypeInstances(final Object keyType) {
+        IMultiset<Object> values = dataTypeMap.get(keyType);
+        return values == null ? Collections.emptySet() : values.distinctValues();
+    }
+    public void removeDataTypeMap(final Object keyType) {
+        dataTypeMap.remove(keyType);
+    }
+    public void insertIntoDataTypeMap(final Object keyType, final Object value) {
+        IMultiset<Object> valMap = dataTypeMap.computeIfAbsent(keyType, CollectionsFactory::emptyMultiset);
+        final boolean firstOccurrence = valMap.addOne(value);
+        
+        isDirty = true;
+        navigationHelper.notifyDataTypeListeners(keyType, value, true, firstOccurrence);
+    }
+    public void removeFromDataTypeMap(final Object keyType, final Object value) {
+        final IMultiset<Object> valMap = dataTypeMap.get(keyType);
+        if (valMap != null) {
+            final boolean lastOccurrence = valMap.removeOne(value);
+            if (lastOccurrence && valMap.isEmpty()) {
+                dataTypeMap.remove(keyType);
+            }
+            isDirty = true;
+            navigationHelper.notifyDataTypeListeners(keyType, value, false, lastOccurrence);
+        }
+    }
+    // END ********* DataTypeMap *********
+    
+    protected Set<EObject> getHoldersOfFeature(Object featureKey) {
+        FeatureData featureData = getFeatureData(featureKey);
+        return featureData.getAllDistinctHolders();
+    }
+    protected Set<Object> getValuesOfFeature(Object featureKey) {
+        FeatureData featureData = getFeatureData(featureKey);
+        return featureData.getAllDistinctValues();
+    }
+    /**
+     * Returns all EClasses that currently have direct instances cached by the index.
+     * <p>
+     * Supertypes will not be returned, unless they have direct instances in the model as well. If not in
+     * <em>wildcard mode</em>, only registered EClasses and their subtypes will be returned.
+     * <p>
+     * Note for advanced users: if a type is represented by multiple EClass objects, one of them is chosen as
+     * representative and returned.
+     */
+    public Set<EClass> getAllCurrentClasses() {
+        final Set<EClass> result = CollectionsFactory.createSet();
+        final Set<Object> classifierKeys = instanceMap.keySet();
+        for (final Object classifierKey : classifierKeys) {
+            final EClassifier knownClassifier = navigationHelper.metaStore.getKnownClassifierForKey(classifierKey);
+            if (knownClassifier instanceof EClass) {
+                result.add((EClass) knownClassifier);
+            }
+        }
+        return result;
+    }
+    Set<Object> getOldValuesForHolderAndFeature(EObject source, Object featureKey) {
+        // while this is slower than using the holderToFeatureToValueMap, we do not want to construct that to avoid
+        // memory overhead
+        Map<Object, IMultiset<EObject>> oldValuesToHolders = getFeatureData(featureKey).valueToHolderMap;
+        Set<Object> oldValues = new HashSet<Object>();
+        for (Entry<Object, IMultiset<EObject>> entry : oldValuesToHolders.entrySet()) {
+            if (entry.getValue().containsNonZero(source)) {
+                oldValues.add(entry.getKey());
+            }
+        }
+        return oldValues;
+    }
+    protected void forgetFeature(Object featureKey) {
+        FeatureData removed = featureDataMap.remove(featureKey);
+        if (valueToFeatureMap != null) {
+            for (Object value : removed.getAllDistinctValues()) {
+                removeFromValueToFeatureMap(featureKey, value);
+            }
+        }
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexMetaStore.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexMetaStore.java
new file mode 100644
index 00000000..52ca3a53
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexMetaStore.java
@@ -0,0 +1,380 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Gabor Bergmann, Istvan Rath 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.core;
+import org.eclipse.emf.common.util.Enumerator;
+import org.eclipse.emf.ecore.*;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.base.api.IndexingLevel;
+import tools.refinery.viatra.runtime.base.api.InstanceListener;
+import tools.refinery.viatra.runtime.base.exception.ViatraBaseException;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import java.util.*;
+import java.util.Map.Entry;
+/**
+ * Stores the indexed metamodel information.
+ *
+ * @author Gabor Bergmann
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class EMFBaseIndexMetaStore {
+    private static final EClass EOBJECT_CLASS = EcorePackage.eINSTANCE.getEObject();
+    private final boolean isDynamicModel;
+    private NavigationHelperImpl navigationHelper;
+    /**
+     *
+     */
+    public EMFBaseIndexMetaStore(final NavigationHelperImpl navigationHelper) {
+        this.navigationHelper = navigationHelper;
+        final BaseIndexOptions options = navigationHelper.getBaseIndexOptions();
+        this.isDynamicModel = options.isDynamicEMFMode();
+    }
+    /**
+     * Supports collision detection and EEnum canonicalization. Used for all EPackages that have types whose instances
+     * were encountered at least once.
+     */
+    private final Set<EPackage> knownPackages = new HashSet<EPackage>();
+    /**
+     * Field variable because it is needed for collision detection. Used for all EClasses whose instances were
+     * encountered at least once.
+     */
+    private final Set<EClassifier> knownClassifiers = new HashSet<EClassifier>();
+    /**
+     * Field variable because it is needed for collision detection. Used for all EStructuralFeatures whose instances
+     * were encountered at least once.
+     */
+    private final Set<EStructuralFeature> knownFeatures = new HashSet<EStructuralFeature>();
+    /**
+     * (EClass or String ID) -> all subtypes in knownClasses
+     */
+    private final Map<Object, Set<Object>> subTypeMap = new HashMap<Object, Set<Object>>();
+    /**
+     * (EClass or String ID) -> all supertypes in knownClasses
+     */
+    private final Map<Object, Set<Object>> superTypeMap = new HashMap<Object, Set<Object>>();
+    /**
+     * EPacakge NsURI -> EPackage instances; this is instance-level to detect collisions
+     */
+    private final IMultiLookup<String, EPackage> uniqueIDToPackage = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    /**
+     * static maps between metamodel elements and their unique IDs
+     */
+    private final Map<EClassifier, String> uniqueIDFromClassifier = new HashMap<EClassifier, String>();
+    private final Map<ETypedElement, String> uniqueIDFromTypedElement = new HashMap<ETypedElement, String>();
+    private final Map<Enumerator, String> uniqueIDFromEnumerator = new HashMap<Enumerator, String>();
+    private final IMultiLookup<String, EClassifier> uniqueIDToClassifier = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    private final IMultiLookup<String, ETypedElement> uniqueIDToTypedElement = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    private final IMultiLookup<String, Enumerator> uniqueIDToEnumerator = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    private final Map<String, Enumerator> uniqueIDToCanonicalEnumerator = new HashMap<String, Enumerator>();
+    /**
+     * Map from enum classes generated for {@link EEnum}s to the actual EEnum.
+     */
+    private Map<Class<?>, EEnum> generatedEENumClasses = new HashMap<Class<?>, EEnum>();
+    /**
+     * @return the eObjectClassKey
+     */
+    public Object getEObjectClassKey() {
+        if (eObjectClassKey == null) {
+            eObjectClassKey = toKey(EOBJECT_CLASS);
+        }
+        return eObjectClassKey;
+    }
+    private Object eObjectClassKey = null;
+    protected Object toKey(final EClassifier classifier) {
+        if (isDynamicModel) {
+            return toKeyDynamicInternal(classifier);
+        } else {
+            maintainMetamodel(classifier);
+            return classifier;
+        }
+    }
+    protected String toKeyDynamicInternal(final EClassifier classifier) {
+        String id = uniqueIDFromClassifier.get(classifier);
+        if (id == null) {
+            Preconditions.checkArgument(!classifier.eIsProxy(),
+                    "Classifier %s is an unresolved proxy", classifier);
+            id = classifier.getEPackage().getNsURI() + "##" + classifier.getName();
+            uniqueIDFromClassifier.put(classifier, id);
+            uniqueIDToClassifier.addPair(id, classifier);
+            // metamodel maintenance will call back toKey(), but now the ID maps are already filled
+            maintainMetamodel(classifier);
+        }
+        return id;
+    }
+    protected String enumToKeyDynamicInternal(Enumerator enumerator) {
+        String id = uniqueIDFromEnumerator.get(enumerator);
+        if (id == null) {
+            if (enumerator instanceof EEnumLiteral) {
+                EEnumLiteral enumLiteral = (EEnumLiteral) enumerator;
+                final EEnum eEnum = enumLiteral.getEEnum();
+                maintainMetamodel(eEnum);
+                id = constructEnumID(eEnum.getEPackage().getNsURI(), eEnum.getName(), enumLiteral.getLiteral());
+                // there might be a generated enum for this enum literal!
+                // generated enum should pre-empt the ecore enum literal as canonical enumerator
+                Enumerator instanceEnum = enumLiteral.getInstance();
+                if (instanceEnum != null && !uniqueIDToCanonicalEnumerator.containsKey(id)) {
+                    uniqueIDToCanonicalEnumerator.put(id, instanceEnum);
+                }
+                // if generated enum not found... delay selection of canonical enumerator
+            } else { // generated enum
+                final EEnum eEnum = generatedEENumClasses.get(enumerator.getClass());
+                if (eEnum != null)
+                    id = constructEnumID(eEnum.getEPackage().getNsURI(), eEnum.getName(), enumerator.getLiteral());
+                else
+                    id = constructEnumID("unkownPackage URI", enumerator.getClass().getSimpleName(),
+                            enumerator.getLiteral());
+                // generated enum should pre-empt the ecore enum literal as canonical enumerator
+                if (!uniqueIDToCanonicalEnumerator.containsKey(id)) {
+                    uniqueIDToCanonicalEnumerator.put(id, enumerator);
+                }
+            }
+            uniqueIDFromEnumerator.put(enumerator, id);
+            uniqueIDToEnumerator.addPair(id, enumerator);
+        }
+        return id;
+    }
+    protected String constructEnumID(String nsURI, String name, String literal) {
+        return String.format("%s##%s##%s", nsURI, name, literal);
+    }
+    protected Object toKey(final EStructuralFeature feature) {
+        if (isDynamicModel) {
+            String id = uniqueIDFromTypedElement.get(feature);
+            if (id == null) {
+                Preconditions.checkArgument(!feature.eIsProxy(),
+                        "Element %s is an unresolved proxy", feature);
+                id = toKeyDynamicInternal((EClassifier) feature.eContainer()) + "##" + feature.getEType().getName()
+                        + "##" + feature.getName();
+                uniqueIDFromTypedElement.put(feature, id);
+                uniqueIDToTypedElement.addPair(id, feature);
+                // metamodel maintenance will call back toKey(), but now the ID maps are already filled
+                maintainMetamodel(feature);
+            }
+            return id;
+        } else {
+            maintainMetamodel(feature);
+            return feature;
+        }
+    }
+    protected Enumerator enumToCanonicalDynamicInternal(final Enumerator value) {
+        final String key = enumToKeyDynamicInternal(value);
+        Enumerator canonicalEnumerator = uniqueIDToCanonicalEnumerator.computeIfAbsent(key,
+                // if no canonical version appointed yet, appoint first version
+                k -> uniqueIDToEnumerator.lookup(k).iterator().next());
+        return canonicalEnumerator;
+    }
+    /**
+     * If in dynamic EMF mode, substitutes enum literals with a canonical version of the enum literal.
+     */
+    protected Object toInternalValueRepresentation(final Object value) {
+        if (isDynamicModel) {
+            if (value instanceof Enumerator)
+                return enumToCanonicalDynamicInternal((Enumerator) value);
+            else
+                return value;
+        } else {
+            return value;
+        }
+    }
+    /**
+     * Checks the {@link EStructuralFeature}'s source and target {@link EPackage} for NsURI collision. An error message
+     * will be logged if a model element from an other {@link EPackage} instance with the same NsURI has been already
+     * processed. The error message will be logged only for the first time for a given {@link EPackage} instance.
+     *
+     * @param classifier
+     *            the classifier instance
+     */
+    protected void maintainMetamodel(final EStructuralFeature feature) {
+        if (!knownFeatures.contains(feature)) {
+            knownFeatures.add(feature);
+            maintainMetamodel(feature.getEContainingClass());
+            maintainMetamodel(feature.getEType());
+        }
+    }
+    /**
+     * put subtype information into cache
+     */
+    protected void maintainMetamodel(final EClassifier classifier) {
+        if (!knownClassifiers.contains(classifier)) {
+            checkEPackage(classifier);
+            knownClassifiers.add(classifier);
+            if (classifier instanceof EClass) {
+                final EClass clazz = (EClass) classifier;
+                final Object clazzKey = toKey(clazz);
+                for (final EClass superType : clazz.getEAllSuperTypes()) {
+                    maintainTypeHierarhyInternal(clazzKey, toKey(superType));
+                }
+                maintainTypeHierarhyInternal(clazzKey, getEObjectClassKey());
+            } else if (classifier instanceof EEnum) {
+                EEnum eEnum = (EEnum) classifier;
+                if (isDynamicModel) {
+                    // if there is a generated enum class, save this model element for describing that class
+                    if (eEnum.getInstanceClass() != null)
+                        generatedEENumClasses.put(eEnum.getInstanceClass(), eEnum);
+                    for (EEnumLiteral eEnumLiteral : eEnum.getELiterals()) {
+                        // create string ID; register generated enum values
+                        enumToKeyDynamicInternal(eEnumLiteral);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Checks the {@link EClassifier}'s {@link EPackage} for NsURI collision. An error message will be logged if a model
+     * element from an other {@link EPackage} instance with the same NsURI has been already processed. The error message
+     * will be logged only for the first time for a given {@link EPackage} instance.
+     *
+     * @param classifier
+     *            the classifier instance
+     */
+    protected void checkEPackage(final EClassifier classifier) {
+        final EPackage ePackage = classifier.getEPackage();
+        if (knownPackages.add(ePackage)) { // this is a new EPackage
+            final String nsURI = ePackage.getNsURI();
+            final IMemoryView<EPackage> packagesOfURI = uniqueIDToPackage.lookupOrEmpty(nsURI);
+            if (!packagesOfURI.containsNonZero(ePackage)) { // this should be true
+                uniqueIDToPackage.addPair(nsURI, ePackage);
+                // collision detection between EPackages (disabled in dynamic model mode)
+                if (!isDynamicModel && packagesOfURI.size() == 2) { // only report the issue if the new EPackage
+                                                                    // instance is the second for the same URI
+                    navigationHelper.processingError(
+                            new ViatraBaseException("NsURI (" + nsURI
+                                    + ") collision detected between different instances of EPackages. If this is normal, try using dynamic EMF mode."),
+                            "process new metamodel elements.");
+                }
+            }
+        }
+    }
+    /**
+     * Maintains subtype hierarchy
+     *
+     * @param subClassKey
+     *            EClass or String id of subclass
+     * @param superClassKey
+     *            EClass or String id of superclass
+     */
+    protected void maintainTypeHierarhyInternal(final Object subClassKey, final Object superClassKey) {
+        // update observed class and instance listener tables according to new subtype information
+        Map<Object, IndexingLevel> allObservedClasses = navigationHelper.getAllObservedClassesInternal();
+        if (allObservedClasses.containsKey(superClassKey)) {
+            // we know that there are no known subtypes of subClassKey at this point, so a single insert should suffice
+            allObservedClasses.put(subClassKey, allObservedClasses.get(superClassKey));
+        }
+        final Map<Object, Map<InstanceListener, Set<EClass>>> instanceListeners = navigationHelper.peekInstanceListeners();
+        if (instanceListeners != null) { // table already constructed
+            for (final Entry<InstanceListener, Set<EClass>> entry : instanceListeners.getOrDefault(superClassKey, Collections.emptyMap()).entrySet()) {
+                final InstanceListener listener = entry.getKey();
+                for (final EClass subscriptionType : entry.getValue()) {
+                    navigationHelper.addInstanceListenerInternal(listener, subscriptionType, subClassKey);
+                }
+            }
+        }
+        // update subtype maps
+        Set<Object> subTypes = subTypeMap.computeIfAbsent(superClassKey, k -> new HashSet<>());
+        subTypes.add(subClassKey);
+        Set<Object> superTypes = superTypeMap.computeIfAbsent(subClassKey, k -> new HashSet<>());
+        superTypes.add(superClassKey);
+    }
+    /**
+     * @return the subTypeMap
+     */
+    protected Map<Object, Set<Object>> getSubTypeMap() {
+        return subTypeMap;
+    }
+    protected Map<Object, Set<Object>> getSuperTypeMap() {
+        return superTypeMap;
+    }
+    /**
+     * Returns the corresponding {@link EStructuralFeature} instance for the id.
+     *
+     * @param featureId
+     *            the id of the feature
+     * @return the {@link EStructuralFeature} instance
+     */
+    public EStructuralFeature getKnownFeature(final String featureId) {
+        final IMemoryView<ETypedElement> features = uniqueIDToTypedElement.lookup(featureId);
+        if (features != null && !features.isEmpty()) {
+            final ETypedElement next = features.iterator().next();
+            if (next instanceof EStructuralFeature) {
+                return (EStructuralFeature) next;
+            }
+        }
+        return null;
+    }
+    public EStructuralFeature getKnownFeatureForKey(Object featureKey) {
+        EStructuralFeature feature;
+        if (isDynamicModel) {
+            feature = getKnownFeature((String) featureKey);
+        } else {
+            feature = (EStructuralFeature) featureKey;
+        }
+        return feature;
+    }
+    /**
+     * Returns the corresponding {@link EClassifier} instance for the id.
+     */
+    public EClassifier getKnownClassifier(final String key) {
+        final IMemoryView<EClassifier> classifiersOfThisID = uniqueIDToClassifier.lookup(key);
+        if (classifiersOfThisID != null && !classifiersOfThisID.isEmpty()) {
+            return classifiersOfThisID.iterator().next();
+        } else {
+            return null;
+        }
+    }
+    public EClassifier getKnownClassifierForKey(Object classifierKey) {
+        EClassifier cls;
+        if (isDynamicModel) {
+            cls = getKnownClassifier((String) classifierKey);
+        } else {
+            cls = (EClassifier) classifierKey;
+        }
+        return cls;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexStatisticsStore.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexStatisticsStore.java
new file mode 100644
index 00000000..de66de78
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFBaseIndexStatisticsStore.java
@@ -0,0 +1,71 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2016, Grill Balázs, IncQuery Labs Ltd.
+ * 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.core;
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClassifier;
+import org.eclipse.emf.ecore.EStructuralFeature;
+/**
+ * @author Grill Balázs
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class EMFBaseIndexStatisticsStore extends AbstractBaseIndexStore {
+    /**
+     * A common map is used to store instance/value statistics. The key can be an {@link EClassifier}, 
+     * {@link EStructuralFeature} or a String ID. 
+     */
+    private final Map<Object, Integer> stats = new HashMap<Object, Integer>();
+    public EMFBaseIndexStatisticsStore(NavigationHelperImpl navigationHelper, Logger logger) {
+        super(navigationHelper, logger);
+    }
+    public void addFeature(Object element, Object feature){
+        addInstance(feature);
+    }
+    
+    public void removeFeature(Object element, Object feature){
+        removeInstance(feature);
+    }
+    
+    public void addInstance(Object key){
+        Integer v = stats.get(key);
+        stats.put(key, v == null ? 1 : v+1);
+    }
+    
+    public void removeInstance(Object key){
+        Integer v = stats.get(key);
+        if(v == null || v <= 0) {
+            navigationHelper.logIncidentStatRemoval(key);
+            return;
+        }
+        if (v.intValue() == 1){
+            stats.remove(key);
+        }else{
+            stats.put(key, v-1);
+        }
+    }
+    public int countInstances(Object key){
+        Integer v = stats.get(key);
+        return v == null ? 0 : v.intValue();
+    }
+    
+    public void removeType(Object key){
+        stats.remove(key);
+    }
+    public int countFeatures(Object feature) {
+        return countInstances(feature);
+    }
+    
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFDataSource.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFDataSource.java
new file mode 100644
index 00000000..35e590f2
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/EMFDataSource.java
@@ -0,0 +1,137 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Set;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphDataSource;
+import tools.refinery.viatra.runtime.base.itc.igraph.IGraphObserver;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.IMemoryView;
+import tools.refinery.viatra.runtime.matchers.util.IMultiset;
+// TODO IBiDirectionalGraphDataSource
+public class EMFDataSource implements IGraphDataSource<EObject> {
+    private List<IGraphObserver<EObject>> observers;
+    private Set<EReference> references;
+    private Set<EClass> classes;
+    private NavigationHelper navigationHelper;
+    private IMultiset<EObject> allEObjects; // contains objects even if only appearing as sources or targets
+    /**
+     * @param navigationHelper
+     * @param references
+     * @param classes
+     *            additional classes to treat as nodes. Source and target classes of references need not be added.
+     */
+    public EMFDataSource(NavigationHelper navigationHelper, Set<EReference> references, Set<EClass> classes) {
+        this.references = references;
+        this.classes = classes;
+        this.observers = new LinkedList<IGraphObserver<EObject>>();
+        this.navigationHelper = navigationHelper;
+    }
+    @Override
+    public Set<EObject> getAllNodes() {
+        return getAllEObjects().distinctValues();
+    }
+    @Override
+    public IMemoryView<EObject> getTargetNodes(EObject source) {
+        IMultiset<EObject> targetNodes = CollectionsFactory.createMultiset();
+        for (EReference ref : references) {
+            final Set<EObject> referenceValues = navigationHelper.getReferenceValues(source, ref);
+            for (EObject referenceValue : referenceValues) {
+                targetNodes.addOne(referenceValue);
+            }
+        }
+        return targetNodes;
+    }
+    @Override
+    public void attachObserver(IGraphObserver<EObject> go) {
+        observers.add(go);
+    }
+    @Override
+    public void attachAsFirstObserver(IGraphObserver<EObject> observer) {
+        observers.add(0, observer);
+    }
+    @Override
+    public void detachObserver(IGraphObserver<EObject> go) {
+        observers.remove(go);
+    }
+    public void notifyEdgeInserted(EObject source, EObject target) {
+        nodeAdditionInternal(source);
+        nodeAdditionInternal(target);
+        for (IGraphObserver<EObject> o : observers) {
+            o.edgeInserted(source, target);
+        }
+    }
+    public void notifyEdgeDeleted(EObject source, EObject target) {
+        for (IGraphObserver<EObject> o : observers) {
+            o.edgeDeleted(source, target);
+        }
+        nodeRemovalInternal(source);
+        nodeRemovalInternal(target);
+    }
+    public void notifyNodeInserted(EObject node) {
+        nodeAdditionInternal(node);
+    }
+    public void notifyNodeDeleted(EObject node) {
+        nodeRemovalInternal(node);
+    }
+    private void nodeAdditionInternal(EObject node) {
+        if (allEObjects.addOne(node))
+            for (IGraphObserver<EObject> o : observers) {
+                o.nodeInserted(node);
+            }
+    }
+    private void nodeRemovalInternal(EObject node) {
+        if (getAllEObjects().removeOne(node))
+            for (IGraphObserver<EObject> o : observers) {
+                o.nodeDeleted(node);
+            }
+    }
+    protected IMultiset<EObject> getAllEObjects() {
+        if (allEObjects == null) {
+            allEObjects = CollectionsFactory.createMultiset();
+            for (EClass clazz : classes) {
+                for (EObject obj : navigationHelper.getAllInstances(clazz)) {                    
+                    allEObjects.addOne(obj);
+                }
+            }
+            for (EReference ref : references) {
+                navigationHelper.processAllFeatureInstances(ref, (source, target) -> {
+                    allEObjects.addOne(source);
+                    allEObjects.addOne((EObject) target);
+                });
+            }
+        }
+        return allEObjects;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperContentAdapter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperContentAdapter.java
new file mode 100644
index 00000000..39271c5b
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperContentAdapter.java
@@ -0,0 +1,750 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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
+ * 
+ * Note: this file contains methods copied from EContentAdapter.java of the EMF project
+ *******************************************************************************/
+package tools.refinery.viatra.runtime.base.core;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.Callable;
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.impl.AdapterImpl;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+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.EContentAdapter;
+import tools.refinery.viatra.runtime.base.api.BaseIndexOptions;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexObjectFilter;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexResourceFilter;
+import tools.refinery.viatra.runtime.base.comprehension.EMFModelComprehension;
+import tools.refinery.viatra.runtime.base.comprehension.EMFVisitor;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperVisitor.ChangeVisitor;
+/**
+ * Content Adapter that recursively attaches itself to the containment hierarchy of an EMF model. 
+ * The purpose is to gather the contents of the model, and to subscribe to model change notifications. 
+ * 
+ * <p> Originally, this was implemented as a subclass of {@link EContentAdapter}. 
+ * Because of Bug 490105, EContentAdapter is no longer a superclass; its code is copied over with modifications.
+ * See {@link EContentAdapter} header for original authorship and copyright information. 
+ * 
+ * @author Gabor Bergmann
+ * @see EContentAdapter
+ * @noextend This class is not intended to be subclassed by clients.
+ */
+public class NavigationHelperContentAdapter extends AdapterImpl {
+    private final NavigationHelperImpl navigationHelper;
+    // move optimization to avoid removing and re-adding entire subtrees
+    EObject ignoreInsertionAndDeletion;
+    // Set<EObject> ignoreRootInsertion = new HashSet<EObject>();
+    // Set<EObject> ignoreRootDeletion = new HashSet<EObject>();
+    private final EMFModelComprehension comprehension;
+    private IBaseIndexObjectFilter objectFilterConfiguration;
+    private IBaseIndexResourceFilter resourceFilterConfiguration;
+    private EMFVisitor removalVisitor;
+    private EMFVisitor insertionVisitor;
+    public NavigationHelperContentAdapter(final NavigationHelperImpl navigationHelper) {
+        this.navigationHelper = navigationHelper;
+        final BaseIndexOptions options = this.navigationHelper.getBaseIndexOptions();
+        objectFilterConfiguration = options.getObjectFilterConfiguration();
+        resourceFilterConfiguration = options.getResourceFilterConfiguration();
+        this.comprehension = navigationHelper.getComprehension();
+        
+        removalVisitor = initChangeVisitor(false);
+        insertionVisitor = initChangeVisitor(true);
+    }
+    /**
+     * Point of customization, called by constructor.
+     */
+    protected ChangeVisitor initChangeVisitor(boolean isInsertion) {
+        return new NavigationHelperVisitor.ChangeVisitor(navigationHelper, isInsertion);
+    }
+    // key representative of the EObject class
+    @Override
+    public void notifyChanged(final Notification notification) {
+        try {
+            this.navigationHelper.coalesceTraversals(new Callable<Void>() {
+                @Override
+                public Void call() throws Exception {
+                    simpleNotifyChanged(notification);
+                    final Object oFeature = notification.getFeature();
+                    final Object oNotifier = notification.getNotifier();
+                    if (oNotifier instanceof EObject && oFeature instanceof EStructuralFeature) {
+                        final EObject notifier = (EObject) oNotifier;
+                        final EStructuralFeature feature = (EStructuralFeature) oFeature;
+                        final boolean notifyLightweightObservers = handleNotification(notification, notifier, feature);
+                        if (notifyLightweightObservers) {
+                            navigationHelper.notifyLightweightObservers(notifier, feature, notification);
+                        }
+                    } else if (oNotifier instanceof Resource) {
+                        if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__IS_LOADED) {
+                            final Resource resource = (Resource) oNotifier;
+                            if (comprehension.isLoading(resource))
+                                navigationHelper.resolutionDelayingResources.add(resource);
+                            else
+                                navigationHelper.resolutionDelayingResources.remove(resource);
+                        }
+                    }
+                    return null;
+                }
+            });
+        } catch (final InvocationTargetException ex) {
+            navigationHelper.processingFatal(ex.getCause(), "handling the following update notification: " + notification);
+        } catch (final Exception ex) {
+            navigationHelper.processingFatal(ex, "handling the following update notification: " + notification);
+        }
+        navigationHelper.notifyBaseIndexChangeListeners();
+    }
+    @SuppressWarnings("deprecation")
+    protected boolean handleNotification(final Notification notification, final EObject notifier,
+            final EStructuralFeature feature) {
+        final Object oldValue = notification.getOldValue();
+        final Object newValue = notification.getNewValue();
+        final int positionInt = notification.getPosition();
+        final Integer position = positionInt == Notification.NO_INDEX ? null : positionInt;
+        final int eventType = notification.getEventType();
+        boolean notifyLightweightObservers = true;
+        switch (eventType) {
+        case Notification.ADD:
+            featureUpdate(true, notifier, feature, newValue, position);
+            break;
+        case Notification.ADD_MANY:
+            for (final Object newElement : (Collection<?>) newValue) {
+                featureUpdate(true, notifier, feature, newElement, position);
+            }
+            break;
+        case Notification.CREATE:
+            notifyLightweightObservers = false;
+            break;
+        case Notification.MOVE:
+            // lightweight observers should be notified on MOVE
+            break; // currently no support for ordering
+        case Notification.REMOVE:
+            featureUpdate(false, notifier, feature, oldValue, position);
+            break;
+        case Notification.REMOVE_MANY:
+            for (final Object oldElement : (Collection<?>) oldValue) {
+                featureUpdate(false, notifier, feature, oldElement, position);
+            }
+            break;
+        case Notification.REMOVING_ADAPTER:
+            notifyLightweightObservers = false;
+            break;
+        case Notification.RESOLVE: // must be EReference
+            if (navigationHelper.isFeatureResolveIgnored(feature))
+                break; // otherwise same as SET
+            if (!feature.isMany()) { // if single-valued, can be removed from delayed resolutions
+                navigationHelper.delayedProxyResolutions.removePairOrNop(notifier, (EReference) feature);
+            }
+            featureUpdate(false, notifier, feature, oldValue, position);
+            featureUpdate(true, notifier, feature, newValue, position);
+            break;
+        case Notification.UNSET:
+        case Notification.SET:
+            if(feature.isMany() && position == null){
+                // spurious UNSET notification of entire collection
+                notifyLightweightObservers = false;
+            } else {
+                featureUpdate(false, notifier, feature, oldValue, position);
+                featureUpdate(true, notifier, feature, newValue, position);
+            }
+            break;
+        default:
+            notifyLightweightObservers = false;
+            break;
+        }
+        return notifyLightweightObservers;
+    }
+    protected void featureUpdate(final boolean isInsertion, final EObject notifier, final EStructuralFeature feature,
+            final Object value, final Integer position) {
+        // this is a safe visitation, no reads will happen, thus no danger of notifications or matcher construction
+        comprehension.traverseFeature(getVisitorForChange(isInsertion), notifier, feature, value, position);
+    }
+    // OFFICIAL ENTRY POINT OF BASE INDEX RELATED PARTS
+    protected void addAdapter(final Notifier notifier) {
+        if (notifier == ignoreInsertionAndDeletion) {
+            return;
+        }
+        try {
+            // cross-resource containment workaround, see Bug 483089 and Bug 483086.
+            if (notifier.eAdapters().contains(this))
+                return;
+            if (objectFilterConfiguration != null && objectFilterConfiguration.isFiltered(notifier)) {
+                return;
+            }
+            this.navigationHelper.coalesceTraversals(new Callable<Void>() {
+                @Override
+                public Void call() throws Exception {
+                    // the object is really traversed BEFORE the notification listener is added,
+                    // so that if a proxy is resolved due to the traversal, we do not get notified about it
+                    if (notifier instanceof EObject) {
+                        comprehension.traverseObject(getVisitorForChange(true), (EObject) notifier);
+                    } else if (notifier instanceof Resource) {
+                        Resource resource = (Resource) notifier;
+                        if (resourceFilterConfiguration != null
+                                && resourceFilterConfiguration.isResourceFiltered(resource)) {
+                            return null;
+                        }
+                        if (comprehension.isLoading(resource))
+                            navigationHelper.resolutionDelayingResources.add(resource);
+                    }
+                    // subscribes to the adapter list, will receive setTarget callback that will spread addAdapter to
+                    // children
+                    simpleAddAdapter(notifier);
+                    return null;
+                }
+            });
+        } catch (final InvocationTargetException ex) {
+            navigationHelper.processingFatal(ex.getCause(), "add the object: " + notifier);
+        } catch (final Exception ex) {
+            navigationHelper.processingFatal(ex, "add the object: " + notifier);
+        }
+    }
+    // OFFICIAL ENTRY POINT OF BASE INDEX RELATED PARTS
+    protected void removeAdapter(final Notifier notifier) {
+        if (notifier == ignoreInsertionAndDeletion) {
+            return;
+        }
+        try {
+            removeAdapterInternal(notifier);
+        } catch (final InvocationTargetException ex) {
+            navigationHelper.processingFatal(ex.getCause(), "remove the object: " + notifier);
+        } catch (final Exception ex) {
+            navigationHelper.processingFatal(ex, "remove the object: " + notifier);
+        }
+    }
+    // The additional boolean options are there to save the cost of extra checks, see Bug 483089 and Bug 483086.
+    protected void removeAdapter(final Notifier notifier, boolean additionalObjectContainerPossible,
+            boolean additionalResourceContainerPossible) {
+        if (notifier == ignoreInsertionAndDeletion) {
+            return;
+        }
+        try {
+            // cross-resource containment workaround, see Bug 483089 and Bug 483086.
+            if (notifier instanceof InternalEObject) {
+                InternalEObject internalEObject = (InternalEObject) notifier;
+                if (additionalResourceContainerPossible) {
+                    Resource eDirectResource = internalEObject.eDirectResource();
+                    if (eDirectResource != null && eDirectResource.eAdapters().contains(this)) {
+                        return;
+                    }
+                }
+                if (additionalObjectContainerPossible) {
+                    InternalEObject eInternalContainer = internalEObject.eInternalContainer();
+                    if (eInternalContainer != null && eInternalContainer.eAdapters().contains(this)) {
+                        return;
+                    }
+                }
+            }
+            removeAdapterInternal(notifier);
+        } catch (final InvocationTargetException ex) {
+            navigationHelper.processingFatal(ex.getCause(), "remove the object: " + notifier);
+        } catch (final Exception ex) {
+            navigationHelper.processingFatal(ex, "remove the object: " + notifier);
+        }
+    }
+    /**
+     * @throws InvocationTargetException
+     */
+    protected void removeAdapterInternal(final Notifier notifier) throws InvocationTargetException {
+        // some non-standard EMF implementations send these 
+        if (!notifier.eAdapters().contains(this)) {
+            // the adapter was not even attached to the notifier
+            navigationHelper.logIncidentAdapterRemoval(notifier);
+            // skip the rest of the method, do not traverse contents
+            //  as they have either never been added to the index or already removed
+            return;
+        }
+        if (objectFilterConfiguration != null && objectFilterConfiguration.isFiltered(notifier)) {
+            return;
+        }
+        this.navigationHelper.coalesceTraversals(new Callable<Void>() {
+            @Override
+            public Void call() throws Exception {
+                if (notifier instanceof EObject) {
+                    final EObject eObject = (EObject) notifier;
+                    comprehension.traverseObject(getVisitorForChange(false), eObject);
+                    navigationHelper.delayedProxyResolutions.lookupAndRemoveAll(eObject);
+                } else if (notifier instanceof Resource) {
+                    if (resourceFilterConfiguration != null
+                            && resourceFilterConfiguration.isResourceFiltered((Resource) notifier)) {
+                        return null;
+                    }
+                    navigationHelper.resolutionDelayingResources.remove(notifier);
+                }
+                // unsubscribes from the adapter list, will receive unsetTarget callback that will spread
+                // removeAdapter to children
+                simpleRemoveAdapter(notifier);
+                return null;
+            }
+        });
+    }
+    protected EMFVisitor getVisitorForChange(final boolean isInsertion) {
+        return isInsertion ? insertionVisitor : removalVisitor;
+    }
+    // WORKAROUND (TMP) for eContents vs. derived features bug
+    protected void setTarget(final EObject target) {
+        basicSetTarget(target);
+        spreadToChildren(target, true);
+    }
+    protected void unsetTarget(final EObject target) {
+        basicUnsetTarget(target);
+        spreadToChildren(target, false);
+    }
+    // Spread adapter removal/addition to children of EObject
+    protected void spreadToChildren(final EObject target, final boolean add) {
+        final EList<EReference> features = target.eClass().getEAllReferences();
+        for (final EReference feature : features) {
+            if (!feature.isContainment()) {
+                continue;
+            }
+            if (!comprehension.representable(feature)) {
+                continue;
+            }
+            if (feature.isMany()) {
+                final Collection<?> values = (Collection<?>) target.eGet(feature);
+                for (final Object value : values) {
+                    final Notifier notifier = (Notifier) value;
+                    if (add) {
+                        addAdapter(notifier);
+                    } else {
+                        removeAdapter(notifier, false, true);
+                    }
+                }
+            } else {
+                final Object value = target.eGet(feature);
+                if (value != null) {
+                    final Notifier notifier = (Notifier) value;
+                    if (add) {
+                        addAdapter(notifier);
+                    } else {
+                        removeAdapter(notifier, false, true);
+                    }
+                }
+            }
+        }
+    }
+    //
+    // ***********************************************************
+    // RENAMED METHODS COPIED OVER FROM EContentAdapter DOWN BELOW
+    // ***********************************************************
+    //
+    
+    /**
+     * Handles a notification by calling {@link #selfAdapt selfAdapter}.
+     */
+    public void simpleNotifyChanged(Notification notification)
+    {
+      selfAdapt(notification);
+      super.notifyChanged(notification);
+    }
+    protected void simpleAddAdapter(Notifier notifier)
+    {
+      EList<Adapter> eAdapters = notifier.eAdapters();
+      if (!eAdapters.contains(this))
+      {
+        eAdapters.add(this); 
+      }
+    }
+    
+    protected void simpleRemoveAdapter(Notifier notifier)
+    {
+      notifier.eAdapters().remove(this); 
+    }
+    // 
+    // *********************************************************
+    // CODE COPIED OVER VERBATIM FROM EContentAdapter DOWN BELOW
+    // *********************************************************
+    //
+    
+    /**
+     * Handles a notification by calling {@link #handleContainment handleContainment}
+     * for any containment-based notification.
+     */
+    protected void selfAdapt(Notification notification)
+    {
+      Object notifier = notification.getNotifier();
+      if (notifier instanceof ResourceSet)
+      {
+        if (notification.getFeatureID(ResourceSet.class) == ResourceSet.RESOURCE_SET__RESOURCES)
+        {
+          handleContainment(notification);
+        }
+      }
+      else if (notifier instanceof Resource)
+      {
+        if (notification.getFeatureID(Resource.class) == Resource.RESOURCE__CONTENTS)
+        {
+          handleContainment(notification);
+        }
+      }
+      else if (notifier instanceof EObject)
+      {
+        Object feature = notification.getFeature();
+        if (feature instanceof EReference)
+        {
+          EReference eReference = (EReference)feature;
+          if (eReference.isContainment())
+          {
+            handleContainment(notification);
+          }
+        }
+      }
+    }
+    /**
+     * Handles a containment change by adding and removing the adapter as appropriate.
+     */
+    protected void handleContainment(Notification notification)
+    {
+      switch (notification.getEventType())
+      {
+        case Notification.RESOLVE:
+        {
+          // We need to be careful that the proxy may be resolved while we are attaching this adapter.
+          // We need to avoid attaching the adapter during the resolve 
+          // and also attaching it again as we walk the eContents() later.
+          // Checking here avoids having to check during addAdapter.
+          //
+          Notifier oldValue = (Notifier)notification.getOldValue();
+          if (oldValue.eAdapters().contains(this))
+          {
+            removeAdapter(oldValue);
+            Notifier newValue = (Notifier)notification.getNewValue();
+            addAdapter(newValue);
+          }
+          break;
+        }
+        case Notification.UNSET:
+        {
+          Object oldValue = notification.getOldValue();
+          if (!Objects.equals(oldValue, Boolean.TRUE) && !Objects.equals(oldValue, Boolean.FALSE))
+          {
+            if (oldValue != null)
+            {
+              removeAdapter((Notifier)oldValue, false, true);
+            }
+            Notifier newValue = (Notifier)notification.getNewValue();
+            if (newValue != null)
+            {
+              addAdapter(newValue);
+            }
+          }
+          break;
+        }
+        case Notification.SET:
+        {
+          Notifier oldValue = (Notifier)notification.getOldValue();
+          if (oldValue != null)
+          {
+            removeAdapter(oldValue, false, true);
+          }
+          Notifier newValue = (Notifier)notification.getNewValue();
+          if (newValue != null)
+          {
+            addAdapter(newValue);
+          }
+          break;
+        }
+        case Notification.ADD:
+        {
+          Notifier newValue = (Notifier)notification.getNewValue();
+          if (newValue != null)
+          {
+            addAdapter(newValue);
+          }
+          break;
+        }
+        case Notification.ADD_MANY:
+        {
+          @SuppressWarnings("unchecked") Collection<Notifier> newValues = (Collection<Notifier>)notification.getNewValue();
+          for (Notifier newValue : newValues)
+          {
+            addAdapter(newValue);
+          }
+          break;
+        }
+        case Notification.REMOVE:
+        {
+          Notifier oldValue = (Notifier)notification.getOldValue();
+          if (oldValue != null)
+          {
+            boolean checkContainer = notification.getNotifier() instanceof Resource;
+            boolean checkResource = notification.getFeature() != null;
+            removeAdapter(oldValue, checkContainer, checkResource);
+          }
+          break;
+        }
+        case Notification.REMOVE_MANY:
+        {
+          boolean checkContainer = notification.getNotifier() instanceof Resource;
+          boolean checkResource = notification.getFeature() != null;
+          @SuppressWarnings("unchecked") Collection<Notifier> oldValues = (Collection<Notifier>)notification.getOldValue();
+          for ( Notifier oldContentValue : oldValues)
+          {
+            removeAdapter(oldContentValue, checkContainer, checkResource);
+          }
+          break;
+        }
+      }
+    }
+    /**
+     * Handles installation of the adapter
+     * by adding the adapter to each of the directly contained objects.
+     */
+    @Override
+    public void setTarget(Notifier target)
+    {
+      if (target instanceof EObject)
+      {
+        setTarget((EObject)target);
+      }
+      else if (target instanceof Resource)
+      {
+        setTarget((Resource)target);
+      }
+      else if (target instanceof ResourceSet)
+      {
+        setTarget((ResourceSet)target);
+      }
+      else
+      {
+        basicSetTarget(target);
+      }
+    }
+    
+    /**
+     * Actually sets the target by calling super.
+     */
+    protected void basicSetTarget(Notifier target)
+    {
+      super.setTarget(target);
+    }
+    /**
+     * Handles installation of the adapter on a Resource
+     * by adding the adapter to each of the directly contained objects.
+     */
+    protected void setTarget(Resource target)
+    {
+      basicSetTarget(target);
+      List<EObject> contents = target.getContents();
+      for (int i = 0, size = contents.size(); i < size; ++i)
+      {
+        Notifier notifier = contents.get(i);
+        addAdapter(notifier);
+      }
+    }
+    /**
+     * Handles installation of the adapter on a ResourceSet
+     * by adding the adapter to each of the directly contained objects.
+     */
+    protected void setTarget(ResourceSet target)
+    {
+      basicSetTarget(target);
+      List<Resource> resources =  target.getResources();
+      for (int i = 0; i < resources.size(); ++i)
+      {
+        Notifier notifier = resources.get(i);
+        addAdapter(notifier);
+      }
+    }
+    /**
+     * Handles undoing the installation of the adapter
+     * by removing the adapter from each of the directly contained objects.
+     */
+    @Override
+    public void unsetTarget(Notifier target)
+    {
+      Object target1 = target;
+    if (target1 instanceof EObject)
+      {
+        unsetTarget((EObject)target1);
+      }
+      else if (target1 instanceof Resource)
+      {
+        unsetTarget((Resource)target1);
+      }
+      else if (target1 instanceof ResourceSet)
+      {
+        unsetTarget((ResourceSet)target1);
+      }
+      else
+      {
+        basicUnsetTarget((Notifier)target1);
+      }
+    }
+    /**
+     * Actually unsets the target by calling super.
+     */
+    protected void basicUnsetTarget(Notifier target)
+    {
+      super.unsetTarget(target);
+    }
+    /**
+     * Handles undoing the installation of the adapter from a Resource
+     * by removing the adapter from each of the directly contained objects.
+     */
+    protected void unsetTarget(Resource target)
+    {
+      basicUnsetTarget(target);
+      List<EObject> contents = target.getContents();
+      for (int i = 0, size = contents.size(); i < size; ++i)
+      {
+        Notifier notifier = contents.get(i);
+        removeAdapter(notifier, true, false);
+      }
+    }
+    /**
+     * Handles undoing the installation of the adapter from a ResourceSet
+     * by removing the adapter from each of the directly contained objects.
+     */
+    protected void unsetTarget(ResourceSet target)
+    {
+      basicUnsetTarget(target);
+      List<Resource> resources =  target.getResources();
+      for (int i = 0; i < resources.size(); ++i)
+      {
+        Notifier notifier = resources.get(i);
+        removeAdapter(notifier, false, false);
+      }
+    }
+    protected boolean resolve()
+    {
+      return true;
+    }
+    // 
+    // *********************************************************
+    // OBSOLETE CODE COPIED OVER FROM EContentAdapter DOWN BELOW
+    // *********************************************************
+    //
+    // *** Preserved on purpose as comments, 
+    // ***  in order to more easily follow future changes to EContentAdapter.
+    //
+//  protected void removeAdapter(Notifier notifier, boolean checkContainer, boolean checkResource)
+//  {
+//    if (checkContainer || checkResource)
+//    {
+//      InternalEObject internalEObject = (InternalEObject) notifier;
+//      if (checkResource)
+//      {
+//        Resource eDirectResource = internalEObject.eDirectResource();
+//        if (eDirectResource != null && eDirectResource.eAdapters().contains(this))
+//        {
+//          return;
+//        }
+//      }
+//      if (checkContainer)
+//      {
+//        InternalEObject eInternalContainer = internalEObject.eInternalContainer();
+//        if (eInternalContainer != null && eInternalContainer.eAdapters().contains(this))
+//        {
+//          return;
+//        }
+//      }
+//    }
+//
+//    removeAdapter(notifier);
+//  }
+//  /**
+//   * Handles undoing the installation of the adapter from an EObject
+//   * by removing the adapter from each of the directly contained objects.
+//   */
+//  protected void unsetTarget(EObject target)
+//  {
+//    basicUnsetTarget(target);
+//    for (Iterator<? extends Notifier> i = resolve() ? 
+//           target.eContents().iterator() : 
+//           ((InternalEList<EObject>)target.eContents()).basicIterator(); 
+//         i.hasNext(); )
+//    {
+//      Notifier notifier = i.next();
+//      removeAdapter(notifier, false, true);
+//    }
+//  }
+//  /**
+//   * Handles installation of the adapter on an EObject
+//   * by adding the adapter to each of the directly contained objects.
+//   */
+//  protected void setTarget(EObject target)
+//  {
+//    basicSetTarget(target);
+//    for (Iterator<? extends Notifier> i = resolve() ? 
+//           target.eContents().iterator() : 
+//           ((InternalEList<? extends Notifier>)target.eContents()).basicIterator();
+//         i.hasNext(); )
+//    {
+//      Notifier notifier = i.next();
+//      addAdapter(notifier);
+//    }
+//  }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperImpl.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperImpl.java
new file mode 100644
index 00000000..2b5d74b5
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperImpl.java
@@ -0,0 +1,1702 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+import org.eclipse.emf.common.notify.NotifyingList;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.*;
+import org.eclipse.emf.ecore.EStructuralFeature.Setting;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.emf.ecore.resource.ResourceSet;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import tools.refinery.viatra.runtime.base.api.*;
+import tools.refinery.viatra.runtime.base.api.IEClassifierProcessor.IEClassProcessor;
+import tools.refinery.viatra.runtime.base.api.IEClassifierProcessor.IEDataTypeProcessor;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexObjectFilter;
+import tools.refinery.viatra.runtime.base.api.filters.IBaseIndexResourceFilter;
+import tools.refinery.viatra.runtime.base.comprehension.EMFModelComprehension;
+import tools.refinery.viatra.runtime.base.comprehension.EMFVisitor;
+import tools.refinery.viatra.runtime.base.core.EMFBaseIndexInstanceStore.FeatureData;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperVisitor.TraversingVisitor;
+import tools.refinery.viatra.runtime.base.core.profiler.ProfilingNavigationHelperContentAdapter;
+import tools.refinery.viatra.runtime.base.exception.ViatraBaseException;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory;
+import tools.refinery.viatra.runtime.matchers.util.CollectionsFactory.MemoryType;
+import tools.refinery.viatra.runtime.matchers.util.IMultiLookup;
+import tools.refinery.viatra.runtime.matchers.util.Preconditions;
+import java.lang.reflect.InvocationTargetException;
+import java.util.*;
+import java.util.Map.Entry;
+import java.util.concurrent.Callable;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import static java.util.function.Function.identity;
+/**
+ * @noextend This class is not intended to be subclassed by clients.
+ * @author Gabor Bergmann and Tamas Szabo
+ */
+public class NavigationHelperImpl implements NavigationHelper {
+    /**
+     * This is never null.
+     */
+    protected IndexingLevel wildcardMode;
+    protected Set<Notifier> modelRoots;
+    private boolean expansionAllowed;
+    private boolean traversalDescendsAlongCrossResourceContainment;
+    // protected NavigationHelperVisitor visitor;
+    protected NavigationHelperContentAdapter contentAdapter;
+    protected final Logger logger;
+    // type object or String id
+    protected Map<Object, IndexingLevel> directlyObservedClasses = new HashMap<Object, IndexingLevel>();
+    // including subclasses; if null, must be recomputed
+    protected Map<Object, IndexingLevel> allObservedClasses = null;
+    protected Map<Object, IndexingLevel> observedDataTypes;
+    protected Map<Object, IndexingLevel> observedFeatures;
+    // ignore RESOLVE for these features, as they are just starting to be observed - see [428458]
+    protected Set<Object> ignoreResolveNotificationFeatures;
+    /**
+     * Feature registration and model traversal is delayed while true
+     */
+    protected boolean delayTraversals = false;
+    /**
+     * Classes (or String ID in dynamic mode) to be registered once the coalescing period is over
+     */
+    protected Map<Object, IndexingLevel> delayedClasses = new HashMap<>();
+    /**
+     * EStructuralFeatures (or String ID in dynamic mode) to be registered once the coalescing period is over
+     */
+    protected Map<Object, IndexingLevel> delayedFeatures = new HashMap<>();
+    /**
+     * EDataTypes (or String ID in dynamic mode) to be registered once the coalescing period is over
+     */
+    protected Map<Object, IndexingLevel> delayedDataTypes = new HashMap<>();
+    /**
+     * Features per EObject to be resolved later (towards the end of a coalescing period when no Resources are loading)
+     */
+    protected IMultiLookup<EObject, EReference> delayedProxyResolutions = CollectionsFactory.createMultiLookup(Object.class, MemoryType.SETS, Object.class);
+    /**
+     * Reasources that are currently loading, implying the proxy resolution attempts should be delayed
+     */
+    protected Set<Resource> resolutionDelayingResources = new HashSet<Resource>();
+    protected Queue<Runnable> traversalCallbacks = new LinkedList<Runnable>();
+    /**
+     * These global listeners will be called after updates.
+     */
+    // private final Set<Runnable> afterUpdateCallbacks;
+    private final Set<EMFBaseIndexChangeListener> baseIndexChangeListeners;
+    private final Map<EObject, Set<LightweightEObjectObserver>> lightweightObservers;
+    // These are the user subscriptions to notifications
+    private final Map<InstanceListener, Set<EClass>> subscribedInstanceListeners;
+    private final Map<FeatureListener, Set<EStructuralFeature>> subscribedFeatureListeners;
+    private final Map<DataTypeListener, Set<EDataType>> subscribedDataTypeListeners;
+    // these are the internal notification tables
+    // (element Type or String id) -> listener -> (subscription types)
+    // if null, must be recomputed from subscriptions
+    // potentially multiple subscription types for each element type because (a) nsURI collisions, (b) multiple
+    // supertypes
+    private Map<Object, Map<InstanceListener, Set<EClass>>> instanceListeners;
+    private Map<Object, Map<FeatureListener, Set<EStructuralFeature>>> featureListeners;
+    private Map<Object, Map<DataTypeListener, Set<EDataType>>> dataTypeListeners;
+    private final Set<IEMFIndexingErrorListener> errorListeners;
+    private final BaseIndexOptions baseIndexOptions;
+    private EMFModelComprehension comprehension;
+    private boolean loggedRegistrationMessage = false;
+    EMFBaseIndexMetaStore metaStore;
+    EMFBaseIndexInstanceStore instanceStore;
+    EMFBaseIndexStatisticsStore statsStore;
+    <T> Set<T> setMinus(Collection<? extends T> a, Collection<T> b) {
+        Set<T> result = new HashSet<T>(a);
+        result.removeAll(b);
+        return result;
+    }
+    @SuppressWarnings("unchecked")
+    <T extends EObject> Set<T> resolveAllInternal(Set<? extends T> a) {
+        if (a == null)
+            a = Collections.emptySet();
+        Set<T> result = new HashSet<T>();
+        for (T t : a) {
+            if (t.eIsProxy()) {
+                result.add((T) EcoreUtil.resolve(t, (ResourceSet) null));
+            } else {
+                result.add(t);
+            }
+        }
+        return result;
+    }
+    Set<Object> resolveClassifiersToKey(Set<? extends EClassifier> classes) {
+        Set<? extends EClassifier> resolveds = resolveAllInternal(classes);
+        Set<Object> result = new HashSet<Object>();
+        for (EClassifier resolved : resolveds) {
+            result.add(toKey(resolved));
+        }
+        return result;
+    }
+    Set<Object> resolveFeaturesToKey(Set<? extends EStructuralFeature> features) {
+        Set<EStructuralFeature> resolveds = resolveAllInternal(features);
+        Set<Object> result = new HashSet<Object>();
+        for (EStructuralFeature resolved : resolveds) {
+            result.add(toKey(resolved));
+        }
+        return result;
+    }
+    @Override
+    public boolean isInWildcardMode() {
+        return isInWildcardMode(IndexingLevel.FULL);
+    }
+    @Override
+    public boolean isInWildcardMode(IndexingLevel level) {
+        return wildcardMode.providesLevel(level);
+    }
+    @Override
+    public boolean isInDynamicEMFMode() {
+        return baseIndexOptions.isDynamicEMFMode();
+    }
+    /**
+     * @return the baseIndexOptions
+     */
+    public BaseIndexOptions getBaseIndexOptions() {
+        return baseIndexOptions.copy();
+    }
+    /**
+     * @return the comprehension
+     */
+    public EMFModelComprehension getComprehension() {
+        return comprehension;
+    }
+    /**
+     * @throws ViatraQueryRuntimeException
+     */
+    public NavigationHelperImpl(Notifier emfRoot, BaseIndexOptions options, Logger logger) {
+        this.baseIndexOptions = options.copy();
+        this.logger = logger;
+        assert (logger != null);
+        this.comprehension = initModelComprehension();
+        this.wildcardMode = baseIndexOptions.getWildcardLevel();
+        this.subscribedInstanceListeners = new HashMap<InstanceListener, Set<EClass>>();
+        this.subscribedFeatureListeners = new HashMap<FeatureListener, Set<EStructuralFeature>>();
+        this.subscribedDataTypeListeners = new HashMap<DataTypeListener, Set<EDataType>>();
+        this.lightweightObservers = CollectionsFactory.createMap();
+        this.observedFeatures = new HashMap<Object, IndexingLevel>();
+        this.ignoreResolveNotificationFeatures = new HashSet<Object>();
+        this.observedDataTypes = new HashMap<Object, IndexingLevel>();
+        metaStore = initMetaStore();
+        instanceStore = initInstanceStore();
+        statsStore = initStatStore();
+        this.contentAdapter = initContentAdapter();
+        this.baseIndexChangeListeners = new HashSet<EMFBaseIndexChangeListener>();
+        this.errorListeners = new LinkedHashSet<IEMFIndexingErrorListener>();
+        this.modelRoots = new HashSet<Notifier>();
+        this.expansionAllowed = false;
+        this.traversalDescendsAlongCrossResourceContainment = false;
+        if (emfRoot != null) {
+            addRootInternal(emfRoot);
+        }
+    }
+    @Override
+    public IndexingLevel getWildcardLevel() {
+        return wildcardMode;
+    }
+    @Override
+    public void setWildcardLevel(final IndexingLevel level) {
+        try{
+            IndexingLevel mergedLevel = NavigationHelperImpl.this.wildcardMode.merge(level);
+            if (mergedLevel != NavigationHelperImpl.this.wildcardMode){
+                NavigationHelperImpl.this.wildcardMode = mergedLevel;
+                // force traversal upon change of wildcard level
+                final NavigationHelperVisitor visitor = initTraversingVisitor(
+                       Collections.<Object, IndexingLevel>emptyMap(), Collections.<Object, IndexingLevel>emptyMap(), Collections.<Object, IndexingLevel>emptyMap(), Collections.<Object, IndexingLevel>emptyMap());
+                coalesceTraversals(() -> traverse(visitor));
+            }
+        } catch (InvocationTargetException ex) {
+            processingFatal(ex.getCause(), "Setting wildcard level: " + level);
+        } catch (Exception ex) {
+            processingFatal(ex, "Setting wildcard level: " + level);
+        }
+    }
+    public NavigationHelperContentAdapter getContentAdapter() {
+        return contentAdapter;
+    }
+    public Map<Object, IndexingLevel> getObservedFeaturesInternal() {
+        return observedFeatures;
+    }
+    public boolean isFeatureResolveIgnored(EStructuralFeature feature) {
+        return ignoreResolveNotificationFeatures.contains(toKey(feature));
+    }
+    @Override
+    public void dispose() {
+        ensureNoListenersForDispose();
+        for (Notifier root : modelRoots) {
+            contentAdapter.removeAdapter(root);
+        }
+    }
+    @Override
+    public Set<Object> getDataTypeInstances(EDataType type) {
+        Object typeKey = toKey(type);
+        return Collections.unmodifiableSet(instanceStore.getDistinctDataTypeInstances(typeKey));
+    }
+    @Override
+    public boolean isInstanceOfDatatype(Object value, EDataType type) {
+        Object typeKey = toKey(type);
+        Set<Object> valMap = instanceStore.getDistinctDataTypeInstances(typeKey);
+        return valMap.contains(value);
+    }
+    protected FeatureData featureData(EStructuralFeature feature) {
+        return instanceStore.getFeatureData(toKey(feature));
+    }
+    @Override
+    public Set<Setting> findByAttributeValue(Object value_) {
+        Object value = toCanonicalValueRepresentation(value_);
+        return getSettingsForTarget(value);
+    }
+    @Override
+    public Set<Setting> findByAttributeValue(Object value_, Collection<EAttribute> attributes) {
+        Object value = toCanonicalValueRepresentation(value_);
+        Set<Setting> retSet = new HashSet<Setting>();
+        for (EAttribute attr : attributes) {
+            for (EObject holder : featureData(attr).getDistinctHoldersOfValue(value)) {
+                retSet.add(new NavigationHelperSetting(attr, holder, value));
+            }
+        }
+        return retSet;
+    }
+    @Override
+    public Set<EObject> findByAttributeValue(Object value_, EAttribute attribute) {
+        Object value = toCanonicalValueRepresentation(value_);
+        final Set<EObject> holders = featureData(attribute).getDistinctHoldersOfValue(value);
+        return Collections.unmodifiableSet(holders);
+    }
+    @Override
+    public void processAllFeatureInstances(EStructuralFeature feature, IStructuralFeatureInstanceProcessor processor) {
+        featureData(feature).forEach(processor);
+    }
+    @Override
+    public void processDirectInstances(EClass type, IEClassProcessor processor) {
+        Object typeKey = toKey(type);
+        processDirectInstancesInternal(type, processor, typeKey);
+    }
+    @Override
+    public void processAllInstances(EClass type, IEClassProcessor processor) {
+        Object typeKey = toKey(type);
+        Set<Object> subTypes = metaStore.getSubTypeMap().get(typeKey);
+        if (subTypes != null) {
+            for (Object subTypeKey : subTypes) {
+                processDirectInstancesInternal(type, processor, subTypeKey);
+            }
+        }
+        processDirectInstancesInternal(type, processor, typeKey);
+    }
+    @Override
+    public void processDataTypeInstances(EDataType type, IEDataTypeProcessor processor) {
+        Object typeKey = toKey(type);
+        for (Object value : instanceStore.getDistinctDataTypeInstances(typeKey)) {
+            processor.process(type, value);
+        }
+    }
+    protected void processDirectInstancesInternal(EClass type, IEClassProcessor processor, Object typeKey) {
+        final Set<EObject> instances = instanceStore.getInstanceSet(typeKey);
+        if (instances != null) {
+            for (EObject eObject : instances) {
+                processor.process(type, eObject);
+            }
+        }
+    }
+    @Override
+    public Set<Setting> getInverseReferences(EObject target) {
+        return getSettingsForTarget(target);
+    }
+    protected Set<Setting> getSettingsForTarget(Object target) {
+        Set<Setting> retSet = new HashSet<Setting>();
+        for (Object featureKey : instanceStore.getFeatureKeysPointingTo(target)) {
+            Set<EObject> holders = instanceStore.getFeatureData(featureKey).getDistinctHoldersOfValue(target);
+            for (EObject holder : holders) {
+                EStructuralFeature feature = metaStore.getKnownFeatureForKey(featureKey);
+                retSet.add(new NavigationHelperSetting(feature, holder, target));
+            }
+        }
+        return retSet;
+    }
+    @Override
+    public Set<Setting> getInverseReferences(EObject target, Collection<EReference> references) {
+        Set<Setting> retSet = new HashSet<>();
+        for (EReference ref : references) {
+            final Set<EObject> holders = featureData(ref).getDistinctHoldersOfValue(target);
+            for (EObject source : holders) {
+                retSet .add(new NavigationHelperSetting(ref, source, target));
+            }
+        }
+        return retSet;
+    }
+    @Override
+    public Set<EObject> getInverseReferences(EObject target, EReference reference) {
+        final Set<EObject> holders = featureData(reference).getDistinctHoldersOfValue(target);
+        return Collections.unmodifiableSet(holders);
+    }
+    @Override
+    @SuppressWarnings("unchecked")
+    public Set<EObject> getReferenceValues(EObject source, EReference reference) {
+        Set<Object> targets = getFeatureTargets(source, reference);
+        return (Set<EObject>) (Set<?>) targets; // this is known to be safe, as EReferences can only point to EObjects
+    }
+    @Override
+    public Set<Object> getFeatureTargets(EObject source, EStructuralFeature _feature) {
+        return Collections.unmodifiableSet(featureData(_feature).getDistinctValuesOfHolder(source));
+    }
+    @Override
+    public boolean isFeatureInstance(EObject source, Object target, EStructuralFeature _feature) {
+        return featureData(_feature).isInstance(source, target);
+    }
+    @Override
+    public Set<EObject> getDirectInstances(EClass type) {
+        Object typeKey = toKey(type);
+        Set<EObject> valSet = instanceStore.getInstanceSet(typeKey);
+        if (valSet == null) {
+            return Collections.emptySet();
+        } else {
+            return Collections.unmodifiableSet(valSet);
+        }
+    }
+    protected Object toKey(EClassifier eClassifier) {
+        return metaStore.toKey(eClassifier);
+    }
+    protected Object toKey(EStructuralFeature feature) {
+        return metaStore.toKey(feature);
+    }
+    @Override
+    public Object toCanonicalValueRepresentation(Object value) {
+        return metaStore.toInternalValueRepresentation(value);
+    }
+    @Override
+    public Set<EObject> getAllInstances(EClass type) {
+        Set<EObject> retSet = new HashSet<EObject>();
+        Object typeKey = toKey(type);
+        Set<Object> subTypes = metaStore.getSubTypeMap().get(typeKey);
+        if (subTypes != null) {
+            for (Object subTypeKey : subTypes) {
+                final Set<EObject> instances = instanceStore.getInstanceSet(subTypeKey);
+                if (instances != null) {
+                    retSet.addAll(instances);
+                }
+            }
+        }
+        final Set<EObject> instances = instanceStore.getInstanceSet(typeKey);
+        if (instances != null) {
+            retSet.addAll(instances);
+        }
+        return retSet;
+    }
+    @Override
+    public boolean isInstanceOfUnscoped(EObject object, EClass clazz) {
+        Object candidateTypeKey = toKey(clazz);
+        Object typeKey = toKey(object.eClass());
+        return doCalculateInstanceOf(candidateTypeKey, typeKey);
+    }
+    @Override
+    public boolean isInstanceOfScoped(EObject object, EClass clazz) {
+        Object typeKey = toKey(object.eClass());
+        if (!doCalculateInstanceOf(toKey(clazz), typeKey)) {
+            return false;
+        }
+        final Set<EObject> instances = instanceStore.getInstanceSet(typeKey);
+        return instances != null && instances.contains(object);
+    }
+    protected boolean doCalculateInstanceOf(Object candidateTypeKey, Object typeKey) {
+        if (candidateTypeKey.equals(typeKey)) return true;
+        if (metaStore.getEObjectClassKey().equals(candidateTypeKey)) return true;
+        Set<Object> superTypes = metaStore.getSuperTypeMap().get(typeKey);
+        return superTypes.contains(candidateTypeKey);
+    }
+    @Override
+    public Set<EObject> findByFeatureValue(Object value_, EStructuralFeature _feature) {
+        Object value = toCanonicalValueRepresentation(value_);
+        return Collections.unmodifiableSet(featureData(_feature).getDistinctHoldersOfValue(value));
+    }
+    @Override
+    public Set<EObject> getHoldersOfFeature(EStructuralFeature _feature) {
+        Object feature = toKey(_feature);
+        return Collections.unmodifiableSet(instanceStore.getHoldersOfFeature(feature));
+    }
+    @Override
+    public Set<Object> getValuesOfFeature(EStructuralFeature _feature) {
+        Object feature = toKey(_feature);
+        return Collections.unmodifiableSet(instanceStore.getValuesOfFeature(feature));
+    }
+    @Override
+    public void addInstanceListener(Collection<EClass> classes, InstanceListener listener) {
+        Set<EClass> registered = this.subscribedInstanceListeners.computeIfAbsent(listener, l -> new HashSet<>());
+        Set<EClass> delta = setMinus(classes, registered);
+        if (!delta.isEmpty()) {
+            registered.addAll(delta);
+            if (instanceListeners != null) { // if already computed
+                for (EClass subscriptionType : delta) {
+                    final Object superElementTypeKey = toKey(subscriptionType);
+                    addInstanceListenerInternal(listener, subscriptionType, superElementTypeKey);
+                    final Set<Object> subTypeKeys = metaStore.getSubTypeMap().get(superElementTypeKey);
+                    if (subTypeKeys != null)
+                        for (Object subTypeKey : subTypeKeys) {
+                            addInstanceListenerInternal(listener, subscriptionType, subTypeKey);
+                        }
+                }
+            }
+        }
+    }
+    @Override
+    public void removeInstanceListener(Collection<EClass> classes, InstanceListener listener) {
+        Set<EClass> restriction = this.subscribedInstanceListeners.get(listener);
+        if (restriction != null) {
+            boolean changed = restriction.removeAll(classes);
+            if (restriction.size() == 0) {
+                this.subscribedInstanceListeners.remove(listener);
+            }
+            if (changed)
+                instanceListeners = null; // recompute later on demand
+        }
+    }
+    @Override
+    public void addFeatureListener(Collection<? extends EStructuralFeature> features, FeatureListener listener) {
+        Set<EStructuralFeature> registered = this.subscribedFeatureListeners.computeIfAbsent(listener, l -> new HashSet<>());
+        Set<EStructuralFeature> delta = setMinus(features, registered);
+        if (!delta.isEmpty()) {
+            registered.addAll(delta);
+            if (featureListeners != null) { // if already computed
+                for (EStructuralFeature subscriptionType : delta) {
+                    addFeatureListenerInternal(listener, subscriptionType, toKey(subscriptionType));
+                }
+            }
+        }
+    }
+    @Override
+    public void removeFeatureListener(Collection<? extends EStructuralFeature> features, FeatureListener listener) {
+        Collection<EStructuralFeature> restriction = this.subscribedFeatureListeners.get(listener);
+        if (restriction != null) {
+            boolean changed = restriction.removeAll(features);
+            if (restriction.size() == 0) {
+                this.subscribedFeatureListeners.remove(listener);
+            }
+            if (changed)
+                featureListeners = null; // recompute later on demand
+        }
+    }
+    @Override
+    public void addDataTypeListener(Collection<EDataType> types, DataTypeListener listener) {
+        Set<EDataType> registered = this.subscribedDataTypeListeners.computeIfAbsent(listener, l -> new HashSet<>());
+        Set<EDataType> delta = setMinus(types, registered);
+        if (!delta.isEmpty()) {
+            registered.addAll(delta);
+            if (dataTypeListeners != null) { // if already computed
+                for (EDataType subscriptionType : delta) {
+                    addDatatypeListenerInternal(listener, subscriptionType, toKey(subscriptionType));
+                }
+            }
+        }
+    }
+    @Override
+    public void removeDataTypeListener(Collection<EDataType> types, DataTypeListener listener) {
+        Collection<EDataType> restriction = this.subscribedDataTypeListeners.get(listener);
+        if (restriction != null) {
+            boolean changed = restriction.removeAll(types);
+            if (restriction.size() == 0) {
+                this.subscribedDataTypeListeners.remove(listener);
+            }
+            if (changed)
+                dataTypeListeners = null; // recompute later on demand
+        }
+    }
+    /**
+     * @return the observedDataTypes
+     */
+    public Map<Object, IndexingLevel> getObservedDataTypesInternal() {
+        return observedDataTypes;
+    }
+    @Override
+    public boolean addLightweightEObjectObserver(LightweightEObjectObserver observer, EObject observedObject) {
+        Set<LightweightEObjectObserver> observers = lightweightObservers.computeIfAbsent(observedObject, CollectionsFactory::emptySet);
+        return observers.add(observer);
+    }
+    @Override
+    public boolean removeLightweightEObjectObserver(LightweightEObjectObserver observer, EObject observedObject) {
+        boolean result = false;
+        Set<LightweightEObjectObserver> observers = lightweightObservers.get(observedObject);
+        if (observers != null) {
+            result = observers.remove(observer);
+            if (observers.isEmpty()) {
+                lightweightObservers.remove(observedObject);
+            }
+        }
+        return result;
+    }
+    public void notifyBaseIndexChangeListeners() {
+        notifyBaseIndexChangeListeners(instanceStore.isDirty);
+        if (instanceStore.isDirty) {
+            instanceStore.isDirty = false;
+        }
+    }
+    /**
+     * This will run after updates.
+     */
+    protected void notifyBaseIndexChangeListeners(boolean baseIndexChanged) {
+        if (!baseIndexChangeListeners.isEmpty()) {
+            for (EMFBaseIndexChangeListener listener : new ArrayList<>(baseIndexChangeListeners)) {
+                try {
+                    if (!listener.onlyOnIndexChange() || baseIndexChanged) {
+                        listener.notifyChanged(baseIndexChanged);
+                    }
+                } catch (Exception ex) {
+                    notifyFatalListener("VIATRA Base encountered an error in delivering notifications about changes. ",
+                            ex);
+                }
+            }
+        }
+    }
+    void notifyDataTypeListeners(final Object typeKey, final Object value, final boolean isInsertion,
+            final boolean firstOrLastOccurrence) {
+        for (final Entry<DataTypeListener, Set<EDataType>> entry : getDataTypeListeners().getOrDefault(typeKey, Collections.emptyMap()).entrySet()) {
+            final DataTypeListener listener = entry.getKey();
+            for (final EDataType subscriptionType : entry.getValue()) {
+                if (isInsertion) {
+                    listener.dataTypeInstanceInserted(subscriptionType, value, firstOrLastOccurrence);
+                } else {
+                    listener.dataTypeInstanceDeleted(subscriptionType, value, firstOrLastOccurrence);
+                }
+            }
+        }
+    }
+    void notifyFeatureListeners(final EObject host, final Object featureKey, final Object value,
+            final boolean isInsertion) {
+        for (final Entry<FeatureListener, Set<EStructuralFeature>> entry : getFeatureListeners().getOrDefault(featureKey, Collections.emptyMap())
+                .entrySet()) {
+            final FeatureListener listener = entry.getKey();
+            for (final EStructuralFeature subscriptionType : entry.getValue()) {
+                if (isInsertion) {
+                    listener.featureInserted(host, subscriptionType, value);
+                } else {
+                    listener.featureDeleted(host, subscriptionType, value);
+                }
+            }
+        }
+    }
+    void notifyInstanceListeners(final Object clazzKey, final EObject instance, final boolean isInsertion) {
+        for (final Entry<InstanceListener, Set<EClass>> entry : getInstanceListeners().getOrDefault(clazzKey, Collections.emptyMap()).entrySet()) {
+            final InstanceListener listener = entry.getKey();
+            for (final EClass subscriptionType : entry.getValue()) {
+                if (isInsertion) {
+                    listener.instanceInserted(subscriptionType, instance);
+                } else {
+                    listener.instanceDeleted(subscriptionType, instance);
+                }
+            }
+        }
+    }
+    void notifyLightweightObservers(final EObject host, final EStructuralFeature feature,
+            final Notification notification) {
+        if (lightweightObservers.containsKey(host)) {
+            Set<LightweightEObjectObserver> observers = lightweightObservers.get(host);
+            for (final LightweightEObjectObserver observer : observers) {
+                observer.notifyFeatureChanged(host, feature, notification);
+            }
+        }
+    }
+    @Override
+    public void addBaseIndexChangeListener(EMFBaseIndexChangeListener listener) {
+        Preconditions.checkArgument(listener != null, "Cannot add null listener!");
+        baseIndexChangeListeners.add(listener);
+    }
+    @Override
+    public void removeBaseIndexChangeListener(EMFBaseIndexChangeListener listener) {
+        Preconditions.checkArgument(listener != null, "Cannot remove null listener!");
+        baseIndexChangeListeners.remove(listener);
+    }
+    @Override
+    public boolean addIndexingErrorListener(IEMFIndexingErrorListener listener) {
+        return errorListeners.add(listener);
+    }
+    @Override
+    public boolean removeIndexingErrorListener(IEMFIndexingErrorListener listener) {
+        return errorListeners.remove(listener);
+    }
+    protected void processingFatal(final Throwable ex, final String task) {
+        notifyFatalListener(logTaskFormat(task), ex);
+    }
+    protected void processingError(final Throwable ex, final String task) {
+        notifyErrorListener(logTaskFormat(task), ex);
+    }
+    public void notifyErrorListener(String message, Throwable t) {
+        logger.error(message, t);
+        for (IEMFIndexingErrorListener listener : new ArrayList<>(errorListeners)) {
+            listener.error(message, t);
+        }
+    }
+    public void notifyFatalListener(String message, Throwable t) {
+        logger.fatal(message, t);
+        for (IEMFIndexingErrorListener listener : new ArrayList<>(errorListeners)) {
+            listener.fatal(message, t);
+        }
+    }
+    protected String logTaskFormat(final String task) {
+        return "VIATRA Query encountered an error in processing the EMF model. " + "This happened while trying to "
+                + task;
+    }
+    protected void considerForExpansion(EObject obj) {
+        if (expansionAllowed) {
+            Resource eResource = obj.eResource();
+            if (eResource != null && eResource.getResourceSet() == null) {
+                expandToAdditionalRoot(eResource);
+            }
+        }
+    }
+    protected void expandToAdditionalRoot(Notifier root) {
+        if (modelRoots.contains(root))
+            return;
+        if (root instanceof ResourceSet) {
+            expansionAllowed = true;
+        } else if (root instanceof Resource) {
+            IBaseIndexResourceFilter resourceFilter = baseIndexOptions.getResourceFilterConfiguration();
+            if (resourceFilter != null && resourceFilter.isResourceFiltered((Resource) root))
+                return;
+        } else { // root instanceof EObject
+            traversalDescendsAlongCrossResourceContainment = true;
+        }
+        final IBaseIndexObjectFilter objectFilter = baseIndexOptions.getObjectFilterConfiguration();
+        if (objectFilter != null && objectFilter.isFiltered(root))
+            return;
+        // no veto by filters
+        modelRoots.add(root);
+        contentAdapter.addAdapter(root);
+        notifyBaseIndexChangeListeners();
+    }
+    /**
+     * @return the expansionAllowed
+     */
+    public boolean isExpansionAllowed() {
+        return expansionAllowed;
+    }
+    public boolean traversalDescendsAlongCrossResourceContainment() {
+        return traversalDescendsAlongCrossResourceContainment;
+    }
+    /**
+     * @return the directlyObservedClasses
+     */
+    public Set<Object> getDirectlyObservedClassesInternal() {
+        return directlyObservedClasses.keySet();
+    }
+    boolean isObservedInternal(Object clazzKey) {
+        return isInWildcardMode() || getAllObservedClassesInternal().containsKey(clazzKey);
+    }
+    /**
+     * Add the given item the map with the given indexing level if it wasn't already added with a higher level.
+     * @param level non-null
+     * @return whether actually changed
+     */
+    protected static <V> boolean putIntoMapMerged(Map<V, IndexingLevel> map, V key, IndexingLevel level) {
+        IndexingLevel l = map.get(key);
+        IndexingLevel merged = level.merge(l);
+        if (merged != l) {
+            map.put(key, merged);
+            return true;
+        } else {
+            return false;
+        }
+    }
+    /**
+     * @return true if actually changed
+     */
+    protected boolean addObservedClassesInternal(Object eClassKey, IndexingLevel level) {
+        boolean changed = putIntoMapMerged(allObservedClasses, eClassKey, level);
+        if (!changed) return false;
+        final Set<Object> subTypes = metaStore.getSubTypeMap().get(eClassKey);
+        if (subTypes != null) {
+            for (Object subType : subTypes) {
+                /*
+                 * It is necessary to check if the class has already been added with a higher indexing level as in case
+                 * of multiple inheritance, a subclass may be registered for statistics only but full indexing may be
+                 * required via one of its super classes.
+                 */
+                putIntoMapMerged(allObservedClasses, subType, level);
+            }
+        }
+        return true;
+    }
+    /**
+     * not just the directly observed classes, but also their known subtypes
+     */
+    public Map<Object, IndexingLevel> getAllObservedClassesInternal() {
+        if (allObservedClasses == null) {
+            allObservedClasses = new HashMap<Object, IndexingLevel>();
+            for (Entry<Object, IndexingLevel> entry : directlyObservedClasses.entrySet()) {
+                Object eClassKey = entry.getKey();
+                IndexingLevel level = entry.getValue();
+                addObservedClassesInternal(eClassKey, level);
+            }
+        }
+        return allObservedClasses;
+    }
+    /**
+     * @return the instanceListeners
+     */
+    Map<Object, Map<InstanceListener, Set<EClass>>> getInstanceListeners() {
+        if (instanceListeners == null) {
+            instanceListeners = CollectionsFactory.createMap();
+            for (Entry<InstanceListener, Set<EClass>> subscription : subscribedInstanceListeners.entrySet()) {
+                final InstanceListener listener = subscription.getKey();
+                for (EClass subscriptionType : subscription.getValue()) {
+                    final Object superElementTypeKey = toKey(subscriptionType);
+                    addInstanceListenerInternal(listener, subscriptionType, superElementTypeKey);
+                    final Set<Object> subTypeKeys = metaStore.getSubTypeMap().get(superElementTypeKey);
+                    if (subTypeKeys != null)
+                        for (Object subTypeKey : subTypeKeys) {
+                            addInstanceListenerInternal(listener, subscriptionType, subTypeKey);
+                        }
+                }
+            }
+        }
+        return instanceListeners;
+    }
+    Map<Object, Map<InstanceListener, Set<EClass>>> peekInstanceListeners() {
+        return instanceListeners;
+    }
+    void addInstanceListenerInternal(final InstanceListener listener, EClass subscriptionType,
+            final Object elementTypeKey) {
+        Set<EClass> subscriptionTypes = instanceListeners
+                .computeIfAbsent(elementTypeKey, k -> CollectionsFactory.createMap())
+                .computeIfAbsent(listener, k -> CollectionsFactory.createSet());
+        subscriptionTypes.add(subscriptionType);
+    }
+    /**
+     * @return the featureListeners
+     */
+    Map<Object, Map<FeatureListener, Set<EStructuralFeature>>> getFeatureListeners() {
+        if (featureListeners == null) {
+            featureListeners = CollectionsFactory.createMap();
+            for (Entry<FeatureListener, Set<EStructuralFeature>> subscription : subscribedFeatureListeners.entrySet()) {
+                final FeatureListener listener = subscription.getKey();
+                for (EStructuralFeature subscriptionType : subscription.getValue()) {
+                    final Object elementTypeKey = toKey(subscriptionType);
+                    addFeatureListenerInternal(listener, subscriptionType, elementTypeKey);
+                }
+            }
+        }
+        return featureListeners;
+    }
+    void addFeatureListenerInternal(final FeatureListener listener, EStructuralFeature subscriptionType,
+            final Object elementTypeKey) {
+        Set<EStructuralFeature> subscriptionTypes = featureListeners
+                .computeIfAbsent(elementTypeKey, k -> CollectionsFactory.createMap())
+                .computeIfAbsent(listener, k -> CollectionsFactory.createSet());
+        subscriptionTypes.add(subscriptionType);
+    }
+    /**
+     * @return the dataTypeListeners
+     */
+    Map<Object, Map<DataTypeListener, Set<EDataType>>> getDataTypeListeners() {
+        if (dataTypeListeners == null) {
+            dataTypeListeners = CollectionsFactory.createMap();
+            for (Entry<DataTypeListener, Set<EDataType>> subscription : subscribedDataTypeListeners.entrySet()) {
+                final DataTypeListener listener = subscription.getKey();
+                for (EDataType subscriptionType : subscription.getValue()) {
+                    final Object elementTypeKey = toKey(subscriptionType);
+                    addDatatypeListenerInternal(listener, subscriptionType, elementTypeKey);
+                }
+            }
+        }
+        return dataTypeListeners;
+    }
+    void addDatatypeListenerInternal(final DataTypeListener listener, EDataType subscriptionType,
+            final Object elementTypeKey) {
+        Set<EDataType> subscriptionTypes = dataTypeListeners
+                .computeIfAbsent(elementTypeKey, k -> CollectionsFactory.createMap())
+                .computeIfAbsent(listener, k -> CollectionsFactory.createSet());
+        subscriptionTypes.add(subscriptionType);
+    }
+    public void registerObservedTypes(Set<EClass> classes, Set<EDataType> dataTypes,
+            Set<? extends EStructuralFeature> features) {
+        registerObservedTypes(classes, dataTypes, features, IndexingLevel.FULL);
+    }
+    @Override
+    public void registerObservedTypes(Set<EClass> classes, Set<EDataType> dataTypes,
+            Set<? extends EStructuralFeature> features, final IndexingLevel level) {
+        if (isRegistrationNecessary(level) && (classes != null || features != null || dataTypes != null)) {
+            final Set<Object> resolvedFeatures = resolveFeaturesToKey(features);
+            final Set<Object> resolvedClasses = resolveClassifiersToKey(classes);
+            final Set<Object> resolvedDatatypes = resolveClassifiersToKey(dataTypes);
+            try {
+                coalesceTraversals(() -> {
+                    Function<Object, IndexingLevel> f = input -> level;
+                    delayedFeatures.putAll(resolvedFeatures.stream().collect(Collectors.toMap(identity(), f)));
+                    delayedDataTypes.putAll(resolvedDatatypes.stream().collect(Collectors.toMap(identity(), f)));
+                    delayedClasses.putAll(resolvedClasses.stream().collect(Collectors.toMap(identity(), f)));
+                });
+            } catch (InvocationTargetException ex) {
+                processingFatal(ex.getCause(), "register en masse the observed EClasses " + resolvedClasses
+                        + " and EDatatypes " + resolvedDatatypes + " and EStructuralFeatures " + resolvedFeatures);
+            } catch (Exception ex) {
+                processingFatal(ex, "register en masse the observed EClasses " + resolvedClasses + " and EDatatypes "
+                        + resolvedDatatypes + " and EStructuralFeatures " + resolvedFeatures);
+            }
+        }
+    }
+    @Override
+    public void unregisterObservedTypes(Set<EClass> classes, Set<EDataType> dataTypes,
+            Set<? extends EStructuralFeature> features) {
+        unregisterEClasses(classes);
+        unregisterEDataTypes(dataTypes);
+        unregisterEStructuralFeatures(features);
+    }
+    @Override
+    public void registerEStructuralFeatures(Set<? extends EStructuralFeature> features, final IndexingLevel level) {
+        if (isRegistrationNecessary(level) && features != null) {
+            final Set<Object> resolved = resolveFeaturesToKey(features);
+            try {
+                coalesceTraversals(() -> resolved.forEach(o -> delayedFeatures.put(o, level)));
+            } catch (InvocationTargetException ex) {
+                processingFatal(ex.getCause(), "register the observed EStructuralFeatures: " + resolved);
+            } catch (Exception ex) {
+                processingFatal(ex, "register the observed EStructuralFeatures: " + resolved);
+            }
+        }
+    }
+    @Override
+    public void unregisterEStructuralFeatures(Set<? extends EStructuralFeature> features) {
+        if (isRegistrationNecessary(IndexingLevel.FULL) && features != null) {
+            final Set<Object> resolved = resolveFeaturesToKey(features);
+            ensureNoListeners(resolved, getFeatureListeners());
+            observedFeatures.keySet().removeAll(resolved);
+            delayedFeatures.keySet().removeAll(resolved);
+            for (Object f : resolved) {
+                instanceStore.forgetFeature(f);
+                statsStore.removeType(f);
+            }
+        }
+    }
+    @Override
+    public void registerEClasses(Set<EClass> classes, final IndexingLevel level) {
+        if (isRegistrationNecessary(level) && classes != null) {
+            final Set<Object> resolvedClasses = resolveClassifiersToKey(classes);
+            try {
+                coalesceTraversals(() -> resolvedClasses.forEach(o -> delayedClasses.put(o, level)));
+            } catch (InvocationTargetException ex) {
+                processingFatal(ex.getCause(), "register the observed EClasses: " + resolvedClasses);
+            } catch (Exception ex) {
+                processingFatal(ex, "register the observed EClasses: " + resolvedClasses);
+            }
+        }
+    }
+    /**
+     * @return true if there is an actual change in the transitively computed observation levels,
+     * warranting an actual traversal
+     */
+    protected boolean startObservingClasses(Map<Object, IndexingLevel> requestedClassObservations) {
+        boolean warrantsTraversal = false;
+        getAllObservedClassesInternal(); // pre-populate
+        for (Entry<Object, IndexingLevel> request : requestedClassObservations.entrySet()) {
+            if (putIntoMapMerged(directlyObservedClasses, request.getKey(), request.getValue())) {
+                // maybe already observed for the sake of a supertype?
+                if (addObservedClassesInternal(request.getKey(), request.getValue())) {
+                    warrantsTraversal = true;
+                };
+            }
+        }
+        return warrantsTraversal;
+    }
+    @Override
+    public void unregisterEClasses(Set<EClass> classes) {
+        if (isRegistrationNecessary(IndexingLevel.FULL) && classes != null) {
+            final Set<Object> resolved = resolveClassifiersToKey(classes);
+            ensureNoListeners(resolved, getInstanceListeners());
+            directlyObservedClasses.keySet().removeAll(resolved);
+            allObservedClasses = null;
+            delayedClasses.keySet().removeAll(resolved);
+            for (Object c : resolved) {
+                instanceStore.removeInstanceSet(c);
+                statsStore.removeType(c);
+            }
+        }
+    }
+    @Override
+    public void registerEDataTypes(Set<EDataType> dataTypes, final IndexingLevel level) {
+        if (isRegistrationNecessary(level) && dataTypes != null) {
+            final Set<Object> resolved = resolveClassifiersToKey(dataTypes);
+            try {
+                coalesceTraversals(() -> resolved.forEach(o -> delayedDataTypes.put(o, level)));
+            } catch (InvocationTargetException ex) {
+                processingFatal(ex.getCause(), "register the observed EDataTypes: " + resolved);
+            } catch (Exception ex) {
+                processingFatal(ex, "register the observed EDataTypes: " + resolved);
+            }
+        }
+    }
+    @Override
+    public void unregisterEDataTypes(Set<EDataType> dataTypes) {
+        if (isRegistrationNecessary(IndexingLevel.FULL) && dataTypes != null) {
+            final Set<Object> resolved = resolveClassifiersToKey(dataTypes);
+            ensureNoListeners(resolved, getDataTypeListeners());
+            observedDataTypes.keySet().removeAll(resolved);
+            delayedDataTypes.keySet().removeAll(resolved);
+            for (Object dataType : resolved) {
+                instanceStore.removeDataTypeMap(dataType);
+                statsStore.removeType(dataType);
+            }
+        }
+    }
+    @Override
+    public boolean isCoalescing() {
+        return delayTraversals;
+    }
+    public void coalesceTraversals(final Runnable runnable) throws InvocationTargetException {
+        coalesceTraversals(() -> {
+            runnable.run();
+            return null;
+        });
+    }
+    @Override
+    public <V> V coalesceTraversals(Callable<V> callable) throws InvocationTargetException {
+        V finalResult = null;
+        if (delayTraversals) { // reentrant case, no special action needed
+            try {
+                finalResult = callable.call();
+            } catch (Exception e) {
+                throw new InvocationTargetException(e);
+            }
+            return finalResult;
+        }
+        boolean firstRun = true;
+        while (callable != null) { // repeat if post-processing needed
+            try {
+                delayTraversals = true;
+                V result = callable.call();
+                if (firstRun) {
+                    firstRun = false;
+                    finalResult = result;
+                }
+                // are there proxies left to be resolved? are we allowed to resolve them now?
+                while ((!delayedProxyResolutions.isEmpty()) && resolutionDelayingResources.isEmpty()) {
+                    // pop first entry
+                    EObject toResolveObject = delayedProxyResolutions.distinctKeys().iterator().next();
+                    EReference toResolveReference = delayedProxyResolutions.lookup(toResolveObject).iterator().next();
+                    delayedProxyResolutions.removePair(toResolveObject, toResolveReference);
+                    // see if we can resolve proxies
+                    comprehension.tryResolveReference(toResolveObject, toResolveReference);
+                }
+                delayTraversals = false;
+                callable = considerRevisit();
+            } catch (Exception e) {
+                // since this is a fatal error, it is OK if delayTraversals remains true,
+                //  hence no need for a try-finally block
+                notifyFatalListener(
+                        "VIATRA Base encountered an error while traversing the EMF model to gather new information. ",
+                        e);
+                throw new InvocationTargetException(e);
+            }
+        }
+        executeTraversalCallbacks();
+        return finalResult;
+    }
+    protected <V> Callable<V> considerRevisit() {
+        // has there been any requests for a retraversal at all?
+        if (!delayedClasses.isEmpty() || !delayedFeatures.isEmpty() || !delayedDataTypes.isEmpty()) {
+            // make copies of requested types so that
+            // (a) original accumulators can be cleaned for the next cycle, also
+            // (b) to remove entries that are already covered, or
+            // (c) for the rare case that a coalesced traversal is invoked during visitation,
+            //      e.g. by a derived feature implementation
+            // initialize the collections empty (but with capacity), fill with new entries
+            final Map<Object, IndexingLevel> toGatherClasses = new HashMap<Object, IndexingLevel>(delayedClasses.size());
+            final Map<Object, IndexingLevel> toGatherFeatures = new HashMap<Object, IndexingLevel>(delayedFeatures.size());
+            final Map<Object, IndexingLevel> toGatherDataTypes = new HashMap<Object, IndexingLevel>(delayedDataTypes.size());
+            for (Entry<Object, IndexingLevel> requested : delayedFeatures.entrySet()) {
+                Object typekey = requested.getKey();
+                IndexingLevel old = observedFeatures.get(typekey);
+                IndexingLevel merged = requested.getValue().merge(old);
+                if (merged != old) toGatherFeatures.put(typekey, merged);
+            }
+            for (Entry<Object, IndexingLevel> requested : delayedClasses.entrySet()) {
+                Object typekey = requested.getKey();
+                IndexingLevel old = directlyObservedClasses.get(typekey);
+                IndexingLevel merged = requested.getValue().merge(old);
+                if (merged != old) toGatherClasses.put(typekey, merged);
+            }
+            for (Entry<Object, IndexingLevel> requested : delayedDataTypes.entrySet()) {
+                Object typekey = requested.getKey();
+                IndexingLevel old = observedDataTypes.get(typekey);
+                IndexingLevel merged = requested.getValue().merge(old);
+                if (merged != old) toGatherDataTypes.put(typekey, merged);
+            }
+            delayedClasses.clear();
+            delayedFeatures.clear();
+            delayedDataTypes.clear();
+            // check if the filtered request sets are empty
+            //      - could be false alarm if we already observe all of them
+            if (!toGatherClasses.isEmpty() || !toGatherFeatures.isEmpty() || !toGatherDataTypes.isEmpty()) {
+                final HashMap<Object, IndexingLevel> oldClasses = new HashMap<Object, IndexingLevel>(
+                        directlyObservedClasses);
+                /* Instance indexing would add extra entries to the statistics store, so we have to clean the
+                 * appropriate entries. If no re-traversal is required, it is detected earlier; at this point we
+                 * only have to consider the target indexing level. See bug
+                 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=518356 for more details.
+                 *
+                 * This has to be executed before the old observed types are updated to check whether the indexing level increased.
+                 *
+                 * Technically, the statsStore cleanup seems only necessary for EDataTypes; otherwise everything
+                 * works as expected, but it seems a better idea to do the cleanup for all types in the same way */
+                toGatherClasses.forEach((key, value) -> {
+                    IndexingLevel oldIndexingLevel = getIndexingLevel(metaStore.getKnownClassifierForKey(key));
+                    if (value.hasInstances() && oldIndexingLevel.hasStatistics() && !oldIndexingLevel.hasInstances()) {
+                        statsStore.removeType(key);
+                    }
+                });
+                toGatherFeatures.forEach((key, value) -> {
+                    IndexingLevel oldIndexingLevel = getIndexingLevel(metaStore.getKnownFeatureForKey(key));
+                    if (value.hasInstances() && oldIndexingLevel.hasStatistics() && !oldIndexingLevel.hasInstances()) {
+                        statsStore.removeType(key);
+                    }
+                });
+                toGatherDataTypes.forEach((key, value) -> {
+                    IndexingLevel oldIndexingLevel = getIndexingLevel(metaStore.getKnownClassifierForKey(key));
+                    if (value.hasInstances() && oldIndexingLevel.hasStatistics() && !oldIndexingLevel.hasInstances()) {
+                        statsStore.removeType(key);
+                    }
+                });
+                // Are there new classes to be observed that are not available via superclasses?
+                //      (at sufficient level)
+                // if yes, model traversal needed
+                // if not, index can be updated without retraversal
+                boolean classesWarrantTraversal = startObservingClasses(toGatherClasses);
+                observedDataTypes.putAll(toGatherDataTypes);
+                observedFeatures.putAll(toGatherFeatures);
+                // So, is an actual traversal needed, or are we done?
+                if (classesWarrantTraversal || !toGatherFeatures.isEmpty() || !toGatherDataTypes.isEmpty()) {
+                    // repeat the cycle with this visit
+                    final NavigationHelperVisitor visitor = initTraversingVisitor(toGatherClasses, toGatherFeatures, toGatherDataTypes, oldClasses);
+                    return new Callable<V>() {
+                        @Override
+                        public V call() throws Exception {
+                            // temporarily ignoring RESOLVE on these features, as they were not observed before
+                            ignoreResolveNotificationFeatures.addAll(toGatherFeatures.keySet());
+                            try {
+                                traverse(visitor);
+                            } finally {
+                                ignoreResolveNotificationFeatures.removeAll(toGatherFeatures.keySet());
+                            }
+                            return null;
+                        }
+                    };
+                }
+            }
+        }
+        return null; // no callable -> no further action
+    }
+    protected void executeTraversalCallbacks() throws InvocationTargetException{
+        final Runnable[] callbacks = traversalCallbacks.toArray(new Runnable[traversalCallbacks.size()]);
+        traversalCallbacks.clear();
+        if (callbacks.length > 0){
+            coalesceTraversals(() -> Arrays.stream(callbacks).forEach(Runnable::run));
+        }
+    }
+    protected void traverse(final NavigationHelperVisitor visitor) {
+        // Cloning model roots avoids a concurrent modification exception
+        for (Notifier root : new HashSet<Notifier>(modelRoots)) {
+            comprehension.traverseModel(visitor, root);
+        }
+        notifyBaseIndexChangeListeners();
+    }
+    /**
+     * Returns a stream of model roots registered to the navigation helper instance
+     * @since 2.3
+     */
+    protected Stream<Notifier> getModelRoots() {
+        return modelRoots.stream();
+    }
+    @Override
+    public void addRoot(Notifier emfRoot) {
+        addRootInternal(emfRoot);
+    }
+    /**
+     * Supports removing model roots
+     * </p>
+     * Note: for now this API is considered experimental thus it is not added to the {@link NavigationHelper} interface.
+     * @since 2.3
+     */
+    protected void removeRoot(Notifier root) {
+        if (!((root instanceof EObject) || (root instanceof Resource) || (root instanceof ResourceSet))) {
+            throw new ViatraBaseException(ViatraBaseException.INVALID_EMFROOT);
+        }
+        if (!modelRoots.contains(root))
+            return;
+        if (root instanceof Resource) {
+            IBaseIndexResourceFilter resourceFilter = getBaseIndexOptions().getResourceFilterConfiguration();
+            if (resourceFilter != null && resourceFilter.isResourceFiltered((Resource) root))
+                return;
+        }
+        final IBaseIndexObjectFilter objectFilter = getBaseIndexOptions().getObjectFilterConfiguration();
+        if (objectFilter != null && objectFilter.isFiltered(root))
+            return;
+        // no veto by filters
+        modelRoots.remove(root);
+        contentAdapter.removeAdapter(root);
+        notifyBaseIndexChangeListeners();
+    }
+    @Override
+    public <T extends EObject> void cheapMoveTo(T element, EList<T> targetContainmentReferenceList) {
+        if (element.eAdapters().contains(contentAdapter)
+                && targetContainmentReferenceList instanceof NotifyingList<?>) {
+            final Object listNotifier = ((NotifyingList<?>) targetContainmentReferenceList).getNotifier();
+            if (listNotifier instanceof Notifier && ((Notifier) listNotifier).eAdapters().contains(contentAdapter)) {
+                contentAdapter.ignoreInsertionAndDeletion = element;
+                try {
+                    targetContainmentReferenceList.add(element);
+                } finally {
+                    contentAdapter.ignoreInsertionAndDeletion = null;
+                }
+            } else {
+                targetContainmentReferenceList.add(element);
+            }
+        } else {
+            targetContainmentReferenceList.add(element);
+        }
+    }
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    @Override
+    public void cheapMoveTo(EObject element, EObject parent, EReference containmentFeature) {
+        metaStore.maintainMetamodel(containmentFeature);
+        if (containmentFeature.isMany())
+            cheapMoveTo(element, (EList) parent.eGet(containmentFeature));
+        else if (element.eAdapters().contains(contentAdapter) && parent.eAdapters().contains(contentAdapter)) {
+            contentAdapter.ignoreInsertionAndDeletion = element;
+            try {
+                parent.eSet(containmentFeature, element);
+            } finally {
+                contentAdapter.ignoreInsertionAndDeletion = null;
+            }
+        } else {
+            parent.eSet(containmentFeature, element);
+        }
+    }
+    protected void addRootInternal(Notifier emfRoot) {
+        if (!((emfRoot instanceof EObject) || (emfRoot instanceof Resource) || (emfRoot instanceof ResourceSet))) {
+            throw new ViatraBaseException(ViatraBaseException.INVALID_EMFROOT);
+        }
+        expandToAdditionalRoot(emfRoot);
+    }
+    @Override
+    public Set<EClass> getAllCurrentClasses() {
+        return instanceStore.getAllCurrentClasses();
+    }
+    protected boolean isRegistrationNecessary(IndexingLevel level) {
+        boolean inWildcardMode = isInWildcardMode(level);
+        if (inWildcardMode && !loggedRegistrationMessage) {
+            loggedRegistrationMessage = true;
+            logger.warn("Type registration/unregistration not required in wildcard mode. This message will not be repeated for future occurences.");
+        }
+        return !inWildcardMode;
+    }
+    protected <X, Y> void ensureNoListeners(Set<Object> unobservedTypes,
+            final Map<Object, Map<X, Set<Y>>> listenerRegistry) {
+        if (!Collections.disjoint(unobservedTypes, listenerRegistry.keySet()))
+            throw new IllegalStateException("Cannot unregister observed types for which there are active listeners");
+    }
+    protected void ensureNoListenersForDispose() {
+        if (!(baseIndexChangeListeners.isEmpty() && subscribedFeatureListeners.isEmpty()
+                && subscribedDataTypeListeners.isEmpty() && subscribedInstanceListeners.isEmpty()))
+            throw new IllegalStateException("Cannot dispose while there are active listeners");
+    }
+    /**
+     * Resamples the values of not well-behaving derived features if those features are also indexed.
+     */
+    @Override
+    public void resampleDerivedFeatures() {
+        // otherwise notifications are delivered anyway
+        if (!baseIndexOptions.isTraverseOnlyWellBehavingDerivedFeatures()) {
+            // get all required classes
+            Set<EClass> allCurrentClasses = instanceStore.getAllCurrentClasses();
+            Set<EStructuralFeature> featuresToSample = new HashSet<>();
+            // collect features to sample
+            for (EClass cls : allCurrentClasses) {
+                EList<EStructuralFeature> features = cls.getEAllStructuralFeatures();
+                for (EStructuralFeature f : features) {
+                    // is feature only sampled?
+                    if (comprehension.onlySamplingFeature(f)) {
+                        featuresToSample.add(f);
+                    }
+                }
+            }
+            final EMFVisitor removalVisitor = contentAdapter.getVisitorForChange(false);
+            final EMFVisitor insertionVisitor = contentAdapter.getVisitorForChange(true);
+            // iterate on instances
+            for (final EStructuralFeature f : featuresToSample) {
+                EClass containingClass = f.getEContainingClass();
+                processAllInstances(containingClass, (type, instance) ->
+                    resampleFeatureValueForHolder(instance, f, insertionVisitor, removalVisitor));
+            }
+            notifyBaseIndexChangeListeners();
+        }
+    }
+    protected void resampleFeatureValueForHolder(EObject source, EStructuralFeature feature,
+            EMFVisitor insertionVisitor, EMFVisitor removalVisitor) {
+        // traverse features and update value
+        Object newValue = source.eGet(feature);
+        Set<Object> oldValues = instanceStore.getOldValuesForHolderAndFeature(source, toKey(feature));
+        if (feature.isMany()) {
+            resampleManyFeatureValueForHolder(source, feature, newValue, oldValues, insertionVisitor, removalVisitor);
+        } else {
+            resampleSingleFeatureValueForHolder(source, feature, newValue, oldValues, insertionVisitor, removalVisitor);
+        }
+    }
+    protected void resampleManyFeatureValueForHolder(EObject source, EStructuralFeature feature, Object newValue,
+            Set<Object> oldValues, EMFVisitor insertionVisitor, EMFVisitor removalVisitor) {
+        InternalEObject internalEObject = (InternalEObject) source;
+        Collection<?> newValues = (Collection<?>) newValue;
+        // add those that are in new but not in old
+        Set<Object> newValueSet = new HashSet<Object>(newValues);
+        newValueSet.removeAll(oldValues);
+        // remove those that are in old but not in new
+        oldValues.removeAll(newValues);
+        if (!oldValues.isEmpty()) {
+            for (Object ov : oldValues) {
+                comprehension.traverseFeature(removalVisitor, source, feature, ov, null);
+            }
+            ENotificationImpl removeNotification = new ENotificationImpl(internalEObject, Notification.REMOVE_MANY,
+                    feature, oldValues, null);
+            notifyLightweightObservers(source, feature, removeNotification);
+        }
+        if (!newValueSet.isEmpty()) {
+            for (Object nv : newValueSet) {
+                comprehension.traverseFeature(insertionVisitor, source, feature, nv, null);
+            }
+            ENotificationImpl addNotification = new ENotificationImpl(internalEObject, Notification.ADD_MANY, feature,
+                    null, newValueSet);
+            notifyLightweightObservers(source, feature, addNotification);
+        }
+    }
+    protected void resampleSingleFeatureValueForHolder(EObject source, EStructuralFeature feature, Object newValue,
+            Set<Object> oldValues, EMFVisitor insertionVisitor, EMFVisitor removalVisitor) {
+        InternalEObject internalEObject = (InternalEObject) source;
+        Object oldValue = oldValues.stream().findFirst().orElse(null);
+        if (!Objects.equals(oldValue, newValue)) {
+            // value changed
+            comprehension.traverseFeature(removalVisitor, source, feature, oldValue, null);
+            comprehension.traverseFeature(insertionVisitor, source, feature, newValue, null);
+            ENotificationImpl notification = new ENotificationImpl(internalEObject, Notification.SET, feature, oldValue,
+                    newValue);
+            notifyLightweightObservers(source, feature, notification);
+        }
+    }
+    @Override
+    public int countAllInstances(EClass type) {
+        int result = 0;
+        Object typeKey = toKey(type);
+        Set<Object> subTypes = metaStore.getSubTypeMap().get(typeKey);
+        if (subTypes != null) {
+            for (Object subTypeKey : subTypes) {
+                result += statsStore.countInstances(subTypeKey);
+            }
+        }
+        result += statsStore.countInstances(typeKey);
+        return result;
+    }
+    @Override
+    public int countDataTypeInstances(EDataType dataType) {
+        return statsStore.countInstances(toKey(dataType));
+    }
+    @Override
+    public int countFeatureTargets(EObject seedSource, EStructuralFeature feature) {
+        return featureData(feature).getDistinctValuesOfHolder(seedSource).size();
+    }
+    @Override
+    public int countFeatures(EStructuralFeature feature) {
+        return statsStore.countFeatures(toKey(feature));
+    }
+    protected IndexingLevel getIndexingLevel(Object type) {
+        if (type instanceof EClass) {
+            return getIndexingLevel((EClass)type);
+        } else if (type instanceof EDataType) {
+            return getIndexingLevel((EDataType)type);
+        } else if (type instanceof EStructuralFeature) {
+            return getIndexingLevel((EStructuralFeature)type);
+        } else {
+            throw new IllegalArgumentException("Unexpected type descriptor " + type.toString());
+        }
+    }
+    @Override
+    public IndexingLevel getIndexingLevel(EClass type) {
+        Object key = toKey(type);
+        IndexingLevel level = directlyObservedClasses.get(key);
+        if (level == null) {
+            level = delayedClasses.get(key);
+        }
+        // Wildcard mode is never null
+        return wildcardMode.merge(level);
+    }
+    @Override
+    public IndexingLevel getIndexingLevel(EDataType type) {
+        Object key = toKey(type);
+        IndexingLevel level = observedDataTypes.get(key);
+        if (level == null) {
+            level = delayedDataTypes.get(key);
+        }
+        // Wildcard mode is never null
+        return wildcardMode.merge(level);
+    }
+    @Override
+    public IndexingLevel getIndexingLevel(EStructuralFeature feature) {
+        Object key = toKey(feature);
+        IndexingLevel level = observedFeatures.get(key);
+        if (level == null) {
+            level = delayedFeatures.get(key);
+        }
+        // Wildcard mode is never null
+        return wildcardMode.merge(level);
+    }
+    @Override
+    public void executeAfterTraversal(final Runnable traversalCallback) throws InvocationTargetException {
+        coalesceTraversals(() -> traversalCallbacks.add(traversalCallback));
+    }
+    /**
+     * Records a non-exception incident such as faulty notifications.
+     * Depending on the strictness setting {@link BaseIndexOptions#isStrictNotificationMode()} and log levels,
+     * this may be treated as a fatal error, merely logged, or just ignored.
+     *
+     * @param msgProvider message supplier that only invoked if the message actually gets logged.
+     *
+     * @since 2.3
+     */
+    protected void logIncident(Supplier<String> msgProvider) {
+        if (baseIndexOptions.isStrictNotificationMode()) {
+            // This will cause e.g. query engine to become tainted
+            String msg = msgProvider.get();
+            notifyFatalListener(msg, new IllegalStateException(msg));
+        } else {
+            if (notificationErrorReported) {
+                if (logger.isDebugEnabled()) {
+                    String msg = msgProvider.get();
+                    logger.debug(msg);
+                }
+            } else {
+                notificationErrorReported = true;
+                String msg = msgProvider.get();
+                logger.error(msg);
+            }
+        }
+    }
+    boolean notificationErrorReported = false;
+// DESIGNATED CUSTOMIZATION POINTS FOR SUBCLASSES
+    /**
+     * Point of customization, called by constructor
+     * @since 2.3
+     */
+    protected NavigationHelperContentAdapter initContentAdapter() {
+        switch (baseIndexOptions.getIndexerProfilerMode()) {
+        case START_DISABLED:
+            return new ProfilingNavigationHelperContentAdapter(this, false);
+        case START_ENABLED:
+            return new ProfilingNavigationHelperContentAdapter(this, true);
+        case OFF:
+        default:
+            return new NavigationHelperContentAdapter(this);
+        }
+    }
+    /**
+     * Point of customization, called by constructor
+     * @since 2.3
+     */
+    protected EMFBaseIndexStatisticsStore initStatStore() {
+        return new EMFBaseIndexStatisticsStore(this, logger);
+    }
+    /**
+     * Point of customization, called by constructor
+     * @since 2.3
+     */
+    protected EMFBaseIndexInstanceStore initInstanceStore() {
+        return new EMFBaseIndexInstanceStore(this, logger);
+    }
+    /**
+     * Point of customization, called by constructor
+     * @since 2.3
+     */
+   protected EMFBaseIndexMetaStore initMetaStore() {
+        return new EMFBaseIndexMetaStore(this);
+    }
+   /**
+    * Point of customization, called by constructor
+    * @since 2.3
+    */
+    protected EMFModelComprehension initModelComprehension() {
+        return new EMFModelComprehension(baseIndexOptions);
+    }
+    /**
+     * Point of customization, called at runtime
+     * @since 2.3
+     */
+    protected TraversingVisitor initTraversingVisitor(final Map<Object, IndexingLevel> toGatherClasses,
+            final Map<Object, IndexingLevel> toGatherFeatures, final Map<Object, IndexingLevel> toGatherDataTypes,
+            final Map<Object, IndexingLevel> oldClasses) {
+        return new NavigationHelperVisitor.TraversingVisitor(this,
+                toGatherFeatures, toGatherClasses, oldClasses, toGatherDataTypes);
+    }
+    /**
+     * Point of customization, e.g. override to suppress
+     * @since 2.3
+     */
+    protected void logIncidentAdapterRemoval(final Notifier notifier) {
+        logIncident(() -> String.format("Erroneous removal of unattached notification adapter from notifier %s", notifier));
+    }
+    /**
+     * Point of customization, e.g. override to suppress
+     * @since 2.3
+     */
+    protected void logIncidentFeatureTupleInsertion(final Object value, final EObject holder, Object featureKey) {
+        logIncident(() -> String.format(
+                "Error: trying to add duplicate value %s to the unique feature %s of host object %s. This indicates some errors in underlying model representation.",
+                value, featureKey, holder));
+    }
+    /**
+     * Point of customization, e.g. override to suppress
+     * @since 2.3
+     */
+   protected void logIncidentFeatureTupleRemoval(final Object value, final EObject holder, Object featureKey) {
+       logIncident(() -> String.format(
+                "Error: trying to remove duplicate value %s from the unique feature %s of host object %s. This indicates some errors in underlying model representation.",
+                value, featureKey, holder));
+    }
+   /**
+    * Point of customization, e.g. override to suppress
+    * @since 2.3
+    */
+    protected void logIncidentInstanceInsertion(final Object keyClass, final EObject value) {
+        logIncident(() -> String.format("Notification received to index %s as a %s, but it already exists in the index. This indicates some errors in underlying model representation.", value, keyClass));
+    }
+    /**
+     * Point of customization, e.g. override to suppress
+     * @since 2.3
+     */
+    protected void logIncidentInstanceRemoval(final Object keyClass, final EObject value) {
+        logIncident(() -> String.format("Notification received to remove %s as a %s, but it is missing from the index. This indicates some errors in underlying model representation.", value, keyClass));
+    }
+    /**
+     * Point of customization, e.g. override to suppress
+     * @since 2.3
+     */
+   protected void logIncidentStatRemoval(Object key) {
+        logIncident(() -> String.format("No instances of %s is registered before calling removeInstance method.", key));
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperSetting.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperSetting.java
new file mode 100644
index 00000000..56556ea8
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperSetting.java
@@ -0,0 +1,73 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.emf.ecore.EStructuralFeature.Setting;
+/**
+ * EStructuralFeature.Setting implementation for the NavigationHelper.
+ * 
+ * @author Tamás Szabó
+ * 
+ */
+public class NavigationHelperSetting implements Setting {
+    private EStructuralFeature feature;
+    private EObject holder;
+    private Object value;
+    public NavigationHelperSetting() {
+        super();
+    }
+    public NavigationHelperSetting(EStructuralFeature feature, EObject holder, Object value) {
+        super();
+        this.feature = feature;
+        this.holder = holder;
+        this.value = value;
+    }
+    @Override
+    public EObject getEObject() {
+        return holder;
+    }
+    @Override
+    public EStructuralFeature getEStructuralFeature() {
+        return feature;
+    }
+    @Override
+    public Object get(boolean resolve) {
+        return value;
+    }
+    @Override
+    public void set(Object newValue) {
+        this.value = newValue;
+    }
+    @Override
+    public boolean isSet() {
+        return (value != null);
+    }
+    @Override
+    public void unset() {
+        this.value = null;
+    }
+    @Override
+    public String toString() {
+        return "feature = " + feature + " holder = " + holder + " value = " + value;
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperType.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperType.java
new file mode 100644
index 00000000..2bab4914
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperType.java
@@ -0,0 +1,14 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+public enum NavigationHelperType {
+    REGISTER, ALL
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperVisitor.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperVisitor.java
new file mode 100644
index 00000000..b5de8d20
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/NavigationHelperVisitor.java
@@ -0,0 +1,441 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EClassifier;
+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 tools.refinery.viatra.runtime.base.api.IndexingLevel;
+import tools.refinery.viatra.runtime.base.comprehension.EMFModelComprehension;
+import tools.refinery.viatra.runtime.base.comprehension.EMFVisitor;
+public abstract class NavigationHelperVisitor extends EMFVisitor {
+    /**
+     * A visitor for processing a single change event. Does not traverse the model. Uses all the observed types.
+     */
+    public static class ChangeVisitor extends NavigationHelperVisitor {
+        // local copies to save actual state, in case visitor has to be saved for later due unresolvable proxies
+        private final IndexingLevel wildcardMode;
+        private final Map<Object, IndexingLevel> allObservedClasses;
+        private final Map<Object, IndexingLevel> observedDataTypes;
+        private final Map<Object, IndexingLevel> observedFeatures;
+        private final Map<Object, Boolean> sampledClasses;
+        public ChangeVisitor(NavigationHelperImpl navigationHelper, boolean isInsertion) {
+            super(navigationHelper, isInsertion, false);
+            wildcardMode = navigationHelper.getWildcardLevel();
+            allObservedClasses = navigationHelper.getAllObservedClassesInternal(); // new HashSet<EClass>();
+            observedDataTypes = navigationHelper.getObservedDataTypesInternal(); // new HashSet<EDataType>();
+            observedFeatures = navigationHelper.getObservedFeaturesInternal(); // new HashSet<EStructuralFeature>();
+            sampledClasses = new HashMap<Object, Boolean>();
+        }
+        @Override
+        protected boolean observesClass(Object eClass) {
+            return wildcardMode.hasInstances() || (IndexingLevel.FULL == allObservedClasses.get(eClass)) || registerSampledClass(eClass);
+        }
+        protected boolean registerSampledClass(Object eClass) {
+            Boolean classAlreadyChecked = sampledClasses.get(eClass);
+            if (classAlreadyChecked != null) {
+                return classAlreadyChecked;
+            }
+            boolean isSampledClass = isSampledClass(eClass);
+            sampledClasses.put(eClass, isSampledClass);
+            // do not modify observation configuration during traversal
+            return false;
+        }
+        @Override
+        protected boolean observesDataType(Object type) {
+            return wildcardMode.hasInstances() || (IndexingLevel.FULL == observedDataTypes.get(type));
+        }
+        @Override
+        protected boolean observesFeature(Object feature) {
+            return wildcardMode.hasInstances() || (IndexingLevel.FULL == observedFeatures.get(feature));
+        }
+        @Override
+        protected boolean countsFeature(Object feature) {
+            return wildcardMode.hasStatistics() || observedFeatures.containsKey(feature) && observedFeatures.get(feature).hasStatistics();
+        }
+        @Override
+        protected boolean countsDataType(Object type) {
+            return wildcardMode.hasStatistics() || observedDataTypes.containsKey(type) && observedDataTypes.get(type).hasStatistics();
+        }
+        @Override
+        protected boolean countsClass(Object eClass) {
+            return wildcardMode.hasStatistics() || allObservedClasses.containsKey(eClass) && allObservedClasses.get(eClass).hasStatistics();
+        }
+    }
+    /**
+     * A visitor for a single-pass traversal of the whole model, processing only the given types and inserting them.
+     */
+    public static class TraversingVisitor extends NavigationHelperVisitor {
+        private final IndexingLevel wildcardMode;
+        Map<Object, IndexingLevel> features;
+        Map<Object, IndexingLevel> newClasses;
+        Map<Object, IndexingLevel> oldClasses; // if decends from an old class, no need to add!
+        Map<Object, IndexingLevel> classObservationMap; // true for a class even if only a supertype is included in classes;
+        Map<Object, IndexingLevel> dataTypes;
+        public TraversingVisitor(NavigationHelperImpl navigationHelper, Map<Object, IndexingLevel> features, Map<Object, IndexingLevel> newClasses,
+                Map<Object, IndexingLevel> oldClasses, Map<Object, IndexingLevel> dataTypes) {
+            super(navigationHelper, true, true);
+            wildcardMode = navigationHelper.getWildcardLevel();
+            this.features = features;
+            this.newClasses = newClasses;
+            this.oldClasses = oldClasses;
+            this.classObservationMap = new HashMap<Object, IndexingLevel>();
+            this.dataTypes = dataTypes;
+        }
+        protected IndexingLevel getExistingIndexingLevel(Object eClass){
+            IndexingLevel result = IndexingLevel.NONE;
+            result = result.merge(oldClasses.get(eClass));
+            result = result.merge(oldClasses.get(metaStore.getEObjectClassKey()));
+            if (IndexingLevel.FULL == result) return result;
+            Set<Object> superTypes = metaStore.getSuperTypeMap().get(eClass);
+            if (superTypes != null){
+                for(Object superType: superTypes){
+                    result = result.merge(oldClasses.get(superType));
+                    if (IndexingLevel.FULL == result) return result;
+                }
+            }
+            return result;
+        }
+        
+        protected IndexingLevel getRequestedIndexingLevel(Object eClass){
+            IndexingLevel result = IndexingLevel.NONE;
+            result = result.merge(newClasses.get(eClass));
+            result = result.merge(newClasses.get(metaStore.getEObjectClassKey()));
+            if (IndexingLevel.FULL == result) return result;
+            Set<Object> superTypes = metaStore.getSuperTypeMap().get(eClass);
+            if (superTypes != null){
+                for(Object superType: superTypes){
+                    result = result.merge(newClasses.get(superType));
+                    if (IndexingLevel.FULL == result) return result;
+                }
+            }
+            return result;
+        }
+        
+        protected IndexingLevel getTraversalIndexing(Object eClass){
+            IndexingLevel level = classObservationMap.get(eClass);
+            if (level == null){
+                IndexingLevel existing = getExistingIndexingLevel(eClass);
+                IndexingLevel requested = getRequestedIndexingLevel(eClass);
+                
+                // Calculate the type of indexing which needs to be executed to reach requested indexing state
+                // Considering indexes which are already available
+                if (existing == requested || existing == IndexingLevel.FULL) return IndexingLevel.NONE;
+                if (requested == IndexingLevel.FULL) return IndexingLevel.FULL;
+                if (requested.hasStatistics() == existing.hasStatistics()) return IndexingLevel.NONE;
+                if (requested.hasStatistics()) return IndexingLevel.STATISTICS;
+                return IndexingLevel.NONE;
+            }
+            return level;
+        }
+        
+        @Override
+        protected boolean observesClass(Object eClass) {
+            if (wildcardMode.hasInstances()) {
+                return true;
+            }
+            return IndexingLevel.FULL == getTraversalIndexing(eClass);
+        }
+        
+        @Override
+        protected boolean countsClass(Object eClass) {
+            return wildcardMode.hasStatistics() || getTraversalIndexing(eClass).hasStatistics();
+        }
+        @Override
+        protected boolean observesDataType(Object type) {
+            return wildcardMode.hasInstances() || (IndexingLevel.FULL == dataTypes.get(type));
+        }
+        @Override
+        protected boolean observesFeature(Object feature) {
+            return wildcardMode.hasInstances() || (IndexingLevel.FULL == features.get(feature));
+        }
+        
+        @Override
+        protected boolean countsDataType(Object type) {
+            return wildcardMode.hasStatistics() || dataTypes.containsKey(type) && dataTypes.get(type).hasStatistics();
+        }
+        
+        @Override
+        protected boolean countsFeature(Object feature) {
+            return wildcardMode.hasStatistics() || features.containsKey(feature) && features.get(feature).hasStatistics();
+        }
+        @Override
+        public boolean avoidTransientContainmentLink(EObject source, EReference reference, EObject targetObject) {
+            return !targetObject.eAdapters().contains(navigationHelper.contentAdapter);
+        }
+    }
+    protected NavigationHelperImpl navigationHelper;
+    boolean isInsertion;
+    boolean descendHierarchy;
+    boolean traverseOnlyWellBehavingDerivedFeatures;
+    EMFBaseIndexInstanceStore instanceStore;
+    EMFBaseIndexStatisticsStore statsStore;
+    EMFBaseIndexMetaStore metaStore;
+    NavigationHelperVisitor(NavigationHelperImpl navigationHelper, boolean isInsertion, boolean descendHierarchy) {
+        super(isInsertion /* preOrder iff insertion */);
+        this.navigationHelper = navigationHelper;
+        instanceStore = navigationHelper.instanceStore;
+        metaStore = navigationHelper.metaStore;
+        statsStore = navigationHelper.statsStore;
+        this.isInsertion = isInsertion;
+        this.descendHierarchy = descendHierarchy;
+        this.traverseOnlyWellBehavingDerivedFeatures = navigationHelper.getBaseIndexOptions()
+                .isTraverseOnlyWellBehavingDerivedFeatures();
+    }
+    @Override
+    public boolean pruneSubtrees(EObject source) {
+        return !descendHierarchy;
+    }
+    @Override
+    public boolean pruneSubtrees(Resource source) {
+        return !descendHierarchy;
+    }
+    @Override
+    public boolean pruneFeature(EStructuralFeature feature) {
+        Object featureKey = toKey(feature);
+        if (observesFeature(featureKey) || countsFeature(featureKey)) {
+            return false;
+        }
+        if (feature instanceof EAttribute){
+            Object dataTypeKey = toKey(((EAttribute) feature).getEAttributeType());
+            if (observesDataType(dataTypeKey) || countsDataType(dataTypeKey)) {
+                return false;
+            }
+        }
+        return !(isInsertion && navigationHelper.isExpansionAllowed() && feature instanceof EReference
+                && !((EReference) feature).isContainment());
+    }
+    /**
+     * @param feature
+     *            key of feature (EStructuralFeature or String id)
+     */
+    protected abstract boolean observesFeature(Object feature);
+    /**
+     * @param feature
+     *            key of data type (EDatatype or String id)
+     */
+    protected abstract boolean observesDataType(Object type);
+    /**
+     * @param feature
+     *            key of class (EClass or String id)
+     */
+    protected abstract boolean observesClass(Object eClass);
+    protected abstract boolean countsFeature(Object feature);
+    
+    protected abstract boolean countsDataType(Object type);
+    
+    protected abstract boolean countsClass(Object eClass);
+    
+    @Override
+    public void visitElement(EObject source) {
+        EClass eClass = source.eClass();
+        if (eClass.eIsProxy()) {
+            eClass = (EClass) EcoreUtil.resolve(eClass, source);
+        }
+        final Object classKey = toKey(eClass);
+        if (observesClass(classKey)) {
+            if (isInsertion) {
+                instanceStore.insertIntoInstanceSet(classKey, source);
+            } else {
+                instanceStore.removeFromInstanceSet(classKey, source);
+            }
+        }
+        if (countsClass(classKey)){
+            if (isInsertion){
+                statsStore.addInstance(classKey);
+            } else {
+                statsStore.removeInstance(classKey);
+            }
+        }
+    }
+    @Override
+    public void visitAttribute(EObject source, EAttribute feature, Object target) {
+        Object featureKey = toKey(feature);
+        final Object eAttributeType = toKey(feature.getEAttributeType());
+        Object internalValueRepresentation = null;
+        if (observesFeature(featureKey)) {
+            // if (internalValueRepresentation == null) // always true
+            internalValueRepresentation = metaStore.toInternalValueRepresentation(target);
+            boolean unique = feature.isUnique();
+            if (isInsertion) {
+                instanceStore.insertFeatureTuple(featureKey, unique, internalValueRepresentation, source);
+            } else {
+                instanceStore.removeFeatureTuple(featureKey, unique, internalValueRepresentation, source);
+            }
+        }
+        if (countsFeature(featureKey)){
+            if (isInsertion) {
+                statsStore.addFeature(source, featureKey);
+            }else{
+                statsStore.removeFeature(source, featureKey);
+            }
+        }
+        if (observesDataType(eAttributeType)) {
+            if (internalValueRepresentation == null)
+                internalValueRepresentation = metaStore.toInternalValueRepresentation(target);
+            if (isInsertion) {
+                instanceStore.insertIntoDataTypeMap(eAttributeType, internalValueRepresentation);
+            } else {
+                instanceStore.removeFromDataTypeMap(eAttributeType, internalValueRepresentation);
+            }
+        }
+        if (countsDataType(eAttributeType)){
+            if (isInsertion){
+                statsStore.addInstance(eAttributeType);
+            } else {
+                statsStore.removeInstance(eAttributeType);
+            }
+        }
+    }
+    @Override
+    public void visitInternalContainment(EObject source, EReference feature, EObject target) {
+        visitReference(source, feature, target);
+    }
+    @Override
+    public void visitNonContainmentReference(EObject source, EReference feature, EObject target) {
+        visitReference(source, feature, target);
+        if (isInsertion) {
+            navigationHelper.considerForExpansion(target);
+        }
+    }
+    protected void visitReference(EObject source, EReference feature, EObject target) {
+        Object featureKey = toKey(feature);
+        if (observesFeature(featureKey)) {
+            boolean unique = feature.isUnique();
+            if (isInsertion) {
+                instanceStore.insertFeatureTuple(featureKey, unique, target, source);
+            } else {
+                instanceStore.removeFeatureTuple(featureKey, unique, target, source);
+            }
+        }
+        if (countsFeature(featureKey)){
+            if (isInsertion){
+                statsStore.addFeature(source, featureKey);
+            } else {
+                statsStore.removeFeature(source, featureKey);
+            }
+        }
+    }
+    
+    @Override
+    // do not attempt to resolve proxies referenced from resources that are still being loaded
+    public boolean attemptProxyResolutions(EObject source, EReference feature) {
+        // emptyness is checked first to avoid costly resource lookup in most cases
+        if (navigationHelper.resolutionDelayingResources.isEmpty())
+            return true;
+        else 
+            return ! navigationHelper.resolutionDelayingResources.contains(source.eResource());
+    }
+    @Override
+    public void visitProxyReference(EObject source, EReference reference, EObject targetObject, Integer position) {
+        if (isInsertion) { // only attempt to resolve proxies if they are inserted
+            // final Object result = source.eGet(reference, true);
+            // if (reference.isMany()) {
+            // // no idea which element to get, have to iterate through
+            // for (EObject touch : (Iterable<EObject>) result);
+            // }
+            if (navigationHelper.isFeatureResolveIgnored(reference))
+                return; // skip resolution; would be ignored anyways
+            if (position != null && reference.isMany() && attemptProxyResolutions(source, reference)) {
+                // there is added value in doing the resolution now, when we know the position
+                // this may save an iteration through the EList if successful
+                @SuppressWarnings("unchecked")
+                EObject touch = ((java.util.List<EObject>) source.eGet(reference, true)).get(position);
+                // if resolution successful, no further action needed
+                if (!touch.eIsProxy())
+                    return;
+            }
+            // otherwise, attempt resolution later, at the end of the coalesced traversal block
+            navigationHelper.delayedProxyResolutions.addPairOrNop(source, reference);
+        }
+    }
+    protected Object toKey(EStructuralFeature feature) {
+        return metaStore.toKey(feature);
+    }
+    protected Object toKey(EClassifier eClassifier) {
+        return metaStore.toKey(eClassifier);
+    }
+    /**
+     * Decides whether the type must be observed in order to allow re-sampling of any of its features. If not
+     * well-behaving features are traversed and there is such a feature for this class, the class will be registered
+     * into the navigation helper, which may cause a re-traversal.
+     * 
+     */
+    protected boolean isSampledClass(Object eClass) {
+        if (!traverseOnlyWellBehavingDerivedFeatures) {
+            // TODO we could save this reverse lookup if the calling method would have the EClass, not just the key
+            EClass knownClass = (EClass) metaStore.getKnownClassifierForKey(eClass);
+            // check features that are traversed, and whether there is any that must be sampled
+            for (EStructuralFeature feature : knownClass.getEAllStructuralFeatures()) {
+                EMFModelComprehension comprehension = navigationHelper.getComprehension();
+                if (comprehension.untraversableDirectly(feature))
+                    continue;
+                final boolean visitorPrunes = pruneFeature(feature);
+                if (visitorPrunes)
+                    continue;
+                // we found a feature to be visited
+                if (comprehension.onlySamplingFeature(feature)) {
+                    // we found a feature that must be sampled
+                    navigationHelper.registerEClasses(Collections.singleton(feature.getEContainingClass()), IndexingLevel.FULL);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    
+    @Override
+    public boolean descendAlongCrossResourceContainments() {
+        return this.navigationHelper.traversalDescendsAlongCrossResourceContainment();
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/TransitiveClosureHelperImpl.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/TransitiveClosureHelperImpl.java
new file mode 100644
index 00000000..552696cb
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/TransitiveClosureHelperImpl.java
@@ -0,0 +1,153 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.core;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+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.util.EContentAdapter;
+import tools.refinery.viatra.runtime.base.api.FeatureListener;
+import tools.refinery.viatra.runtime.base.api.IndexingLevel;
+import tools.refinery.viatra.runtime.base.api.InstanceListener;
+import tools.refinery.viatra.runtime.base.api.NavigationHelper;
+import tools.refinery.viatra.runtime.base.api.TransitiveClosureHelper;
+import tools.refinery.viatra.runtime.base.itc.alg.incscc.IncSCCAlg;
+import tools.refinery.viatra.runtime.base.itc.alg.misc.IGraphPathFinder;
+import tools.refinery.viatra.runtime.base.itc.igraph.ITcObserver;
+/**
+ * Implementation class for the {@link TransitiveClosureHelper}.
+ * It uses a {@link NavigationHelper} instance to wrap an EMF model 
+ * and make it suitable for the {@link IncSCCAlg} algorithm. 
+ * 
+ * @author Tamas Szabo
+ * 
+ */
+public class TransitiveClosureHelperImpl extends EContentAdapter implements TransitiveClosureHelper,
+        ITcObserver<EObject>, FeatureListener, InstanceListener {
+    private IncSCCAlg<EObject> sccAlg;
+    private Set<EStructuralFeature> features;
+    private Set<EClass> classes;
+    private EMFDataSource dataSource;
+    private List<ITcObserver<EObject>> tcObservers;
+    private NavigationHelper navigationHelper;
+    private boolean disposeBaseIndexWhenDisposed;
+    
+    public TransitiveClosureHelperImpl(final NavigationHelper navigationHelper, boolean disposeBaseIndexWhenDisposed, Set<EReference> references) {
+        this.tcObservers = new ArrayList<ITcObserver<EObject>>();
+        this.navigationHelper = navigationHelper;
+        this.disposeBaseIndexWhenDisposed = disposeBaseIndexWhenDisposed;
+        
+        //NavigationHelper only accepts Set<EStructuralFeature> upon registration
+        this.features = new HashSet<EStructuralFeature>(references);
+        this.classes = collectEClasses();
+        /*this.classes = Collections.emptySet();*/
+        if (!navigationHelper.isInWildcardMode())
+            navigationHelper.registerObservedTypes(classes, null, features, IndexingLevel.FULL);
+        
+        this.navigationHelper.addFeatureListener(features, this);
+        this.navigationHelper.addInstanceListener(classes, this);
+        
+        this.dataSource = new EMFDataSource(navigationHelper, references, classes);
+        
+        this.sccAlg = new IncSCCAlg<EObject>(dataSource);
+        this.sccAlg.attachObserver(this);
+    }
+    
+    private Set<EClass> collectEClasses() {
+        Set<EClass> classes = new HashSet<EClass>();
+        for (EStructuralFeature ref : features) {
+            classes.add(ref.getEContainingClass());
+            classes.add(((EReference) ref).getEReferenceType());
+        }
+        return classes;
+    }
+    @Override
+    public void attachObserver(ITcObserver<EObject> to) {
+        this.tcObservers.add(to);
+    }
+    @Override
+    public void detachObserver(ITcObserver<EObject> to) {
+        this.tcObservers.remove(to);
+    }
+    @Override
+    public Set<EObject> getAllReachableTargets(EObject source) {
+        return this.sccAlg.getAllReachableTargets(source);
+    }
+    @Override
+    public Set<EObject> getAllReachableSources(EObject target) {
+        return this.sccAlg.getAllReachableSources(target);
+    }
+    @Override
+    public boolean isReachable(EObject source, EObject target) {
+        return this.sccAlg.isReachable(source, target);
+    }
+    @Override
+    public void tupleInserted(EObject source, EObject target) {
+        for (ITcObserver<EObject> to : tcObservers) {
+            to.tupleInserted(source, target);
+        }
+    }
+    @Override
+    public void tupleDeleted(EObject source, EObject target) {
+        for (ITcObserver<EObject> to : tcObservers) {
+            to.tupleDeleted(source, target);
+        }
+    }
+    @Override
+    public void dispose() {
+        this.sccAlg.dispose();
+        this.navigationHelper.removeInstanceListener(classes, this);
+        this.navigationHelper.removeFeatureListener(features, this);
+        
+        if (disposeBaseIndexWhenDisposed)
+            this.navigationHelper.dispose();
+    }
+    @Override
+    public void featureInserted(EObject host, EStructuralFeature feature, Object value) {
+        this.dataSource.notifyEdgeInserted(host, (EObject) value);
+    }
+    @Override
+    public void featureDeleted(EObject host, EStructuralFeature feature, Object value) {
+        this.dataSource.notifyEdgeDeleted(host, (EObject) value);
+    }
+    @Override
+    public void instanceInserted(EClass clazz, EObject instance) {
+        this.dataSource.notifyNodeInserted(instance);
+    }
+    @Override
+    public void instanceDeleted(EClass clazz, EObject instance) {
+        this.dataSource.notifyNodeDeleted(instance);
+    }
+    
+    @Override
+    public IGraphPathFinder<EObject> getPathFinder() {
+        return this.sccAlg.getPathFinder();
+    }
+}
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/profiler/ProfilingNavigationHelperContentAdapter.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/profiler/ProfilingNavigationHelperContentAdapter.java
new file mode 100644
index 00000000..3ab15430
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/core/profiler/ProfilingNavigationHelperContentAdapter.java
@@ -0,0 +1,155 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2019, Laszlo Gati, Zoltan Ujhelyi, IncQuery Labs Ltd.
+ * 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.core.profiler;
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.common.notify.Notifier;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperContentAdapter;
+import tools.refinery.viatra.runtime.base.core.NavigationHelperImpl;
+/**
+ * 
+ * @noinstantiate This class is not intended to be instantiated by clients.
+ * @noreference This class is not intended to be referenced by clients.
+ */
+public final class ProfilingNavigationHelperContentAdapter extends NavigationHelperContentAdapter {
+    private static class StopWatch {
+        private long currentStartTimeNs = 0l;
+        private long totalElapsedTimeNs = 0l;
+        private boolean running = false;
+        /**
+         * Puts the timer in running state and saves the current time.
+         */
+        private void start() {
+            currentStartTimeNs = System.nanoTime();
+            running = true;
+        }
+        /**
+         * Puts the the timer in stopped state and saves the total time spent in started
+         * state between the last reset and now
+         */
+        private void stop() {
+            totalElapsedTimeNs = getTotalElapsedTimeNs();
+            running = false;
+        }
+        /**
+         * @return time between the last start and now
+         */
+        private long getCurrentElapsedTimeNs() {
+            return System.nanoTime() - currentStartTimeNs;
+        }
+        /**
+         * @return the total time spent in started state between the last reset and now
+         */
+        private long getTotalElapsedTimeNs() {
+            return running ? getCurrentElapsedTimeNs() + totalElapsedTimeNs : totalElapsedTimeNs;
+        }
+        
+        /**
+         * Saves the current time and resets all the time spent between the last reset and now.
+         */
+        private void resetTime() {
+            currentStartTimeNs = System.currentTimeMillis();
+            totalElapsedTimeNs = 0;
+        }
+    }
+    long notificationCount = 0l;
+    StopWatch watch = new StopWatch();
+    boolean isEnabled = false;
+    
+    boolean measurement = false;
+    public ProfilingNavigationHelperContentAdapter(NavigationHelperImpl navigationHelper, boolean enabled) {
+        super(navigationHelper);
+        this.isEnabled = enabled;
+    }
+    @Override
+    public void notifyChanged(Notification notification) {
+        // Handle possibility of reentrancy
+        if (isEnabled && !measurement) {
+                try {
+                        measurement = true;
+                        notificationCount++;
+                        watch.start();
+                        super.notifyChanged(notification);
+                } finally {
+                        watch.stop();
+                        measurement = false;
+                }
+        } else {
+                super.notifyChanged(notification);
+        }
+    }
+    @Override
+    public void setTarget(Notifier target) {
+        // Handle possibility of reentrancy
+        if (isEnabled && !measurement) {
+                try {
+                        measurement = true;
+                        notificationCount++;
+                        watch.start();
+                        super.setTarget(target);
+                } finally {
+                        watch.stop();
+                        measurement = false;
+                }
+        } else {
+                super.setTarget(target);
+        }
+    }
+    @Override
+    public void unsetTarget(Notifier target) {
+        // Handle possibility of reentrancy
+        if (isEnabled && !measurement) {
+                try {
+                        measurement = true;
+                        notificationCount++;
+                        watch.start();
+                        super.unsetTarget(target);
+                } finally {
+                        watch.stop();
+                        measurement = false;
+                }
+        } else {
+                super.unsetTarget(target);
+        }
+    }
+    
+    public long getNotificationCount() {
+        return notificationCount;
+    }
+    public long getTotalMeasuredTimeInMS() {
+        return watch.getTotalElapsedTimeNs() / 1_000_000l;
+    }
+    public boolean isEnabled() {
+        return isEnabled;
+    }
+    public void setEnabled(boolean isEnabled) {
+        this.isEnabled = isEnabled;
+    }
+    public void resetMeasurement() {
+        notificationCount = 0;
+        watch.resetTime();
+    }
+}
+\ No newline at end of file
diff --git a/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/exception/ViatraBaseException.java b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/exception/ViatraBaseException.java
new file mode 100644
index 00000000..fe656c34
--- /dev/null
+++ b/subprojects/viatra-runtime-base/src/main/java/tools/refinery/viatra/runtime/base/exception/ViatraBaseException.java
@@ -0,0 +1,25 @@
+/*******************************************************************************
+ * Copyright (c) 2010-2012, Tamas Szabo, Gabor Bergmann, Istvan Rath 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.exception;
+import tools.refinery.viatra.runtime.matchers.ViatraQueryRuntimeException;
+public class ViatraBaseException extends ViatraQueryRuntimeException {
+    private static final long serialVersionUID = -5145445047912938251L;
+    public static final String EMPTY_REF_LIST = "At least one EReference must be provided!";
+    public static final String INVALID_EMFROOT = "Emf navigation helper can only be attached on the contents of an EMF EObject, Resource, or ResourceSet.";
+    public ViatraBaseException(String s) {
+        super(s);
+    }
+}