11 files changed, 105 insertions, 105 deletions

diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
index 999d349a..44ed1505 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryBuilderImpl.java
@@ -117,7 +117,7 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
         public ViatraModelQueryStoreAdapterImpl createStoreAdapter(ModelStore store) {
                 validateSymbols(store);
                 dnf2PQuery.assertNoUnusedHints();
-                return new ViatraModelQueryStoreAdapterImpl(store, buildEngineOptions(), dnf2PQuery.getRelationViews(),
+                return new ViatraModelQueryStoreAdapterImpl(store, buildEngineOptions(), dnf2PQuery.getSymbolViews(),
                                 Collections.unmodifiableMap(querySpecifications), Collections.unmodifiableSet(vacuousQueries));
         }
 
@@ -140,11 +140,11 @@ public class ViatraModelQueryBuilderImpl extends AbstractModelAdapterBuilder imp
 
         private void validateSymbols(ModelStore store) {
                 var symbols = store.getSymbols();
-                for (var relationView : dnf2PQuery.getRelationViews().keySet()) {
-                        var symbol = relationView.getSymbol();
+                for (var symbolView : dnf2PQuery.getSymbolViews().keySet()) {
+                        var symbol = symbolView.getSymbol();
                         if (!symbols.contains(symbol)) {
-                                throw new IllegalArgumentException("Cannot query relation view %s: symbol %s is not in the model"
-                                                .formatted(relationView, symbol));
+                                throw new IllegalArgumentException("Cannot query view %s: symbol %s is not in the model"
+                                                .formatted(symbolView, symbol));
                         }
                 }
         }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
index aa102a35..11a3c7fd 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/ViatraModelQueryStoreAdapterImpl.java
@@ -13,20 +13,20 @@ import tools.refinery.store.model.ModelStore;
 import tools.refinery.store.query.dnf.AnyQuery;
 import tools.refinery.store.query.viatra.ViatraModelQueryStoreAdapter;
 import tools.refinery.store.query.viatra.internal.matcher.RawPatternMatcher;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.util.*;
 
 public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAdapter {
         private final ModelStore store;
         private final ViatraQueryEngineOptions engineOptions;
-        private final Map<AnyRelationView, IInputKey> inputKeys;
+        private final Map<AnySymbolView, IInputKey> inputKeys;
         private final Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications;
         private final Set<AnyQuery> vacuousQueries;
         private final Set<AnyQuery> allQueries;
 
         ViatraModelQueryStoreAdapterImpl(ModelStore store, ViatraQueryEngineOptions engineOptions,
-                                                                         Map<AnyRelationView, IInputKey> inputKeys,
+                                                                         Map<AnySymbolView, IInputKey> inputKeys,
                                                                          Map<AnyQuery, IQuerySpecification<RawPatternMatcher>> querySpecifications,
                                                                          Set<AnyQuery> vacuousQueries) {
                 this.store = store;
@@ -45,11 +45,11 @@ public class ViatraModelQueryStoreAdapterImpl implements ViatraModelQueryStoreAd
                 return store;
         }
 
-        public Collection<AnyRelationView> getRelationViews() {
+        public Collection<AnySymbolView> getSymbolViews() {
                 return inputKeys.keySet();
         }
 
-        public Map<AnyRelationView, IInputKey> getInputKeys() {
+        public Map<AnySymbolView, IInputKey> getInputKeys() {
                 return inputKeys;
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
index 07a5a6ea..cf96b7fd 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalQueryMetaContext.java
@@ -10,8 +10,8 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.InputKeyImplication;
 import org.eclipse.viatra.query.runtime.matchers.context.common.JavaTransitiveInstancesKey;
 import tools.refinery.store.query.term.DataSort;
-import tools.refinery.store.query.viatra.internal.pquery.RelationViewWrapper;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.viatra.internal.pquery.SymbolViewWrapper;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.util.*;
 
@@ -19,9 +19,9 @@ import java.util.*;
  * The meta context information for String scopes.
  */
 public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
-        private final Map<AnyRelationView, IInputKey> inputKeys;
+        private final Map<AnySymbolView, IInputKey> inputKeys;
 
-        RelationalQueryMetaContext(Map<AnyRelationView, IInputKey> inputKeys) {
+        RelationalQueryMetaContext(Map<AnySymbolView, IInputKey> inputKeys) {
                 this.inputKeys = inputKeys;
         }
 
@@ -47,23 +47,23 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
                 if (implyingKey instanceof JavaTransitiveInstancesKey) {
                         return List.of();
                 }
-                var relationView = checkKey(implyingKey);
-                var relationViewImplications = relationView.getImpliedRelationViews();
+                var symbolView = checkKey(implyingKey);
+                var relationViewImplications = symbolView.getImpliedRelationViews();
                 var inputKeyImplications = new HashSet<InputKeyImplication>(relationViewImplications.size());
                 for (var relationViewImplication : relationViewImplications) {
-                        if (!relationView.equals(relationViewImplication.implyingRelationView())) {
+                        if (!symbolView.equals(relationViewImplication.implyingView())) {
                                 throw new IllegalArgumentException("Relation view %s returned unrelated implication %s".formatted(
-                                                relationView, relationViewImplication));
+                                                symbolView, relationViewImplication));
                         }
-                        var impliedInputKey = inputKeys.get(relationViewImplication.impliedRelationView());
+                        var impliedInputKey = inputKeys.get(relationViewImplication.impliedView());
                         // Ignore implications not relevant for any queries included in the model.
                         if (impliedInputKey != null) {
                                 inputKeyImplications.add(new InputKeyImplication(implyingKey, impliedInputKey,
                                                 relationViewImplication.impliedIndices()));
                         }
                 }
-                var sorts = relationView.getSorts();
-                int arity = relationView.arity();
+                var sorts = symbolView.getSorts();
+                int arity = symbolView.arity();
                 for (int i = 0; i < arity; i++) {
                         var sort = sorts.get(i);
                         if (sort instanceof DataSort<?> dataSort) {
@@ -99,20 +99,20 @@ public class RelationalQueryMetaContext extends AbstractQueryMetaContext {
                 return flattened;
         }
 
-        private static void checkValidIndices(AnyRelationView relationView, Collection<Integer> indices) {
+        private static void checkValidIndices(AnySymbolView relationView, Collection<Integer> indices) {
                 indices.stream().filter(relationView::invalidIndex).findAny().ifPresent(i -> {
                         throw new IllegalArgumentException("Index %d is invalid for %s".formatted(i, relationView));
                 });
         }
 
-        public AnyRelationView checkKey(IInputKey key) {
-                if (!(key instanceof RelationViewWrapper wrapper)) {
+        public AnySymbolView checkKey(IInputKey key) {
+                if (!(key instanceof SymbolViewWrapper wrapper)) {
                         throw new IllegalArgumentException("The input key %s is not a valid input key".formatted(key));
                 }
-                var relationView = wrapper.getWrappedKey();
-                if (!inputKeys.containsKey(relationView)) {
+                var symbolView = wrapper.getWrappedKey();
+                if (!inputKeys.containsKey(symbolView)) {
                         throw new IllegalArgumentException("The input key %s is not present in the model".formatted(key));
                 }
-                return relationView;
+                return symbolView;
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
index 71943737..0f2daca8 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/context/RelationalRuntimeContext.java
@@ -13,9 +13,9 @@ import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import org.eclipse.viatra.query.runtime.matchers.util.Accuracy;
 import tools.refinery.store.model.Model;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.viatra.internal.pquery.RelationViewWrapper;
+import tools.refinery.store.query.viatra.internal.pquery.SymbolViewWrapper;
 import tools.refinery.store.query.viatra.internal.update.ModelUpdateListener;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
 import java.lang.reflect.InvocationTargetException;
 import java.util.Iterator;
@@ -59,9 +59,9 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
 
         @Override
         public boolean isIndexed(IInputKey key, IndexingService service) {
-                if (key instanceof RelationViewWrapper wrapper) {
-                        var relationalKey = wrapper.getWrappedKey();
-                        return this.modelUpdateListener.containsRelationView(relationalKey);
+                if (key instanceof SymbolViewWrapper wrapper) {
+                        var symbolViewKey = wrapper.getWrappedKey();
+                        return this.modelUpdateListener.containsSymbolView(symbolViewKey);
                 } else {
                         return false;
                 }
@@ -74,13 +74,13 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext {
                 }
         }
 
-        AnyRelationView checkKey(IInputKey key) {
-                if (key instanceof RelationViewWrapper wrappedKey) {
-                        var relationViewKey = wrappedKey.getWrappedKey();
-                        if (modelUpdateListener.containsRelationView(relationViewKey)) {
-                                return relationViewKey;
+        AnySymbolView checkKey(IInputKey key) {
+                if (key instanceof SymbolViewWrapper wrappedKey) {
+                        var symbolViewKey = wrappedKey.getWrappedKey();
+                        if (modelUpdateListener.containsSymbolView(symbolViewKey)) {
+                                return symbolViewKey;
                         } else {
-                                throw new IllegalStateException("Query is asking for non-indexed key %s".formatted(relationViewKey));
+                                throw new IllegalStateException("Query is asking for non-indexed key %s".formatted(symbolViewKey));
                         }
                 } else {
                         throw new IllegalStateException("Query is asking for non-relational key");
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
index 714d41c0..b511a5c7 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/Dnf2PQuery.java
@@ -29,7 +29,7 @@ import tools.refinery.store.query.term.ConstantTerm;
 import tools.refinery.store.query.term.StatefulAggregator;
 import tools.refinery.store.query.term.StatelessAggregator;
 import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 import tools.refinery.store.util.CycleDetectingMapper;
 
 import java.util.*;
@@ -53,8 +53,8 @@ public class Dnf2PQuery {
                 return mapper.map(dnfQuery);
         }
 
-        public Map<AnyRelationView, IInputKey> getRelationViews() {
-                return wrapperFactory.getRelationViews();
+        public Map<AnySymbolView, IInputKey> getSymbolViews() {
+                return wrapperFactory.getSymbolViews();
         }
 
         public void hint(Dnf dnf, QueryEvaluationHint hint) {
@@ -165,8 +165,8 @@ public class Dnf2PQuery {
                         if (constraint instanceof Dnf dnf) {
                                 var pattern = translate(dnf);
                                 new PositivePatternCall(body, substitution, pattern);
-                        } else if (constraint instanceof AnyRelationView relationView) {
-                                var inputKey = wrapperFactory.getInputKey(relationView);
+                        } else if (constraint instanceof AnySymbolView symbolView) {
+                                var inputKey = wrapperFactory.getInputKey(symbolView);
                                 new TypeConstraint(body, substitution, inputKey);
                         } else {
                                 throw new IllegalArgumentException("Unknown Constraint: " + constraint);
@@ -178,8 +178,8 @@ public class Dnf2PQuery {
                         PQuery pattern;
                         if (constraint instanceof Dnf dnf) {
                                 pattern = translate(dnf);
-                        } else if (constraint instanceof AnyRelationView relationView) {
-                                pattern = wrapperFactory.wrapRelationViewIdentityArguments(relationView);
+                        } else if (constraint instanceof AnySymbolView symbolView) {
+                                pattern = wrapperFactory.wrapSymbolViewIdentityArguments(symbolView);
                         } else {
                                 throw new IllegalArgumentException("Unknown Constraint: " + constraint);
                         }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
index 30f848a6..0d046455 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/QueryWrapperFactory.java
@@ -21,8 +21,8 @@ import tools.refinery.store.query.dnf.DnfClause;
 import tools.refinery.store.query.dnf.DnfUtils;
 import tools.refinery.store.query.literal.AbstractCallLiteral;
 import tools.refinery.store.query.term.Variable;
-import tools.refinery.store.query.view.AnyRelationView;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.SymbolView;
 import tools.refinery.store.util.CycleDetectingMapper;
 
 import java.util.*;
@@ -30,7 +30,7 @@ import java.util.function.ToIntFunction;
 
 class QueryWrapperFactory {
         private final Dnf2PQuery dnf2PQuery;
-        private final Map<AnyRelationView, RelationViewWrapper> view2WrapperMap = new LinkedHashMap<>();
+        private final Map<AnySymbolView, SymbolViewWrapper> view2WrapperMap = new LinkedHashMap<>();
         private final CycleDetectingMapper<RemappedConstraint, RawPQuery> wrapConstraint = new CycleDetectingMapper<>(
                         RemappedConstraint::toString, this::doWrapConstraint);
 
@@ -38,12 +38,12 @@ class QueryWrapperFactory {
                 this.dnf2PQuery = dnf2PQuery;
         }
 
-        public PQuery wrapRelationViewIdentityArguments(AnyRelationView relationView) {
-                var identity = new int[relationView.arity()];
+        public PQuery wrapSymbolViewIdentityArguments(AnySymbolView symbolView) {
+                var identity = new int[symbolView.arity()];
                 for (int i = 0; i < identity.length; i++) {
                         identity[i] = i;
                 }
-                return maybeWrapConstraint(relationView, identity);
+                return maybeWrapConstraint(symbolView, identity);
         }
         public WrappedCall maybeWrapConstraint(AbstractCallLiteral callLiteral, DnfClause clause) {
                 var arguments = callLiteral.getArguments();
@@ -112,8 +112,8 @@ class QueryWrapperFactory {
                 }
                 var argumentTuple = Tuples.flatTupleOf(arguments);
 
-                if (constraint instanceof RelationView<?> relationView) {
-                        new TypeConstraint(body, argumentTuple, getInputKey(relationView));
+                if (constraint instanceof SymbolView<?> view) {
+                        new TypeConstraint(body, argumentTuple, getInputKey(view));
                 } else if (constraint instanceof Dnf dnf) {
                         var calledPQuery = dnf2PQuery.translate(dnf);
                         new PositivePatternCall(body, argumentTuple, calledPQuery);
@@ -125,11 +125,11 @@ class QueryWrapperFactory {
                 return embeddedPQuery;
         }
 
-        public IInputKey getInputKey(AnyRelationView relationView) {
-                return view2WrapperMap.computeIfAbsent(relationView, RelationViewWrapper::new);
+        public IInputKey getInputKey(AnySymbolView symbolView) {
+                return view2WrapperMap.computeIfAbsent(symbolView, SymbolViewWrapper::new);
         }
 
-        public Map<AnyRelationView, IInputKey> getRelationViews() {
+        public Map<AnySymbolView, IInputKey> getSymbolViews() {
                 return Collections.unmodifiableMap(view2WrapperMap);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SymbolViewWrapper.java
index 02da932b..a777613e 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/RelationViewWrapper.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/pquery/SymbolViewWrapper.java
@@ -6,10 +6,10 @@
 package tools.refinery.store.query.viatra.internal.pquery;
 
 import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper;
-import tools.refinery.store.query.view.AnyRelationView;
+import tools.refinery.store.query.view.AnySymbolView;
 
-public class RelationViewWrapper extends BaseInputKeyWrapper<AnyRelationView> {
-        public RelationViewWrapper(AnyRelationView wrappedKey) {
+public class SymbolViewWrapper extends BaseInputKeyWrapper<AnySymbolView> {
+        public SymbolViewWrapper(AnySymbolView wrappedKey) {
                 super(wrappedKey);
         }
 
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
index c612574f..986bb0b1 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/ModelUpdateListener.java
@@ -9,43 +9,43 @@ import org.eclipse.viatra.query.runtime.matchers.context.IInputKey;
 import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextListener;
 import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.AnyRelationView;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.AnySymbolView;
+import tools.refinery.store.query.view.SymbolView;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class ModelUpdateListener {
-        private final Map<AnyRelationView, RelationViewUpdateListener<?>> relationViewUpdateListeners;
+        private final Map<AnySymbolView, SymbolViewUpdateListener<?>> symbolViewUpdateListeners;
 
         public ModelUpdateListener(ViatraModelQueryAdapterImpl adapter) {
-                var relationViews = adapter.getStoreAdapter().getInputKeys().keySet();
-                relationViewUpdateListeners = new HashMap<>(relationViews.size());
-                for (var relationView : relationViews) {
-                        registerView(adapter, (RelationView<?>) relationView);
+                var symbolViews = adapter.getStoreAdapter().getInputKeys().keySet();
+                symbolViewUpdateListeners = new HashMap<>(symbolViews.size());
+                for (var symbolView : symbolViews) {
+                        registerView(adapter, (SymbolView<?>) symbolView);
                 }
         }
 
-        private <T> void registerView(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView) {
+        private <T> void registerView(ViatraModelQueryAdapterImpl adapter, SymbolView<T> view) {
                 var model = adapter.getModel();
-                var interpretation = model.getInterpretation(relationView.getSymbol());
-                var listener = RelationViewUpdateListener.of(adapter, relationView, interpretation);
-                relationViewUpdateListeners.put(relationView, listener);
+                var interpretation = model.getInterpretation(view.getSymbol());
+                var listener = SymbolViewUpdateListener.of(adapter, view, interpretation);
+                symbolViewUpdateListeners.put(view, listener);
         }
 
-        public boolean containsRelationView(AnyRelationView relationView) {
-                return relationViewUpdateListeners.containsKey(relationView);
+        public boolean containsSymbolView(AnySymbolView relationView) {
+                return symbolViewUpdateListeners.containsKey(relationView);
         }
 
-        public void addListener(IInputKey key, AnyRelationView relationView, ITuple seed,
+        public void addListener(IInputKey key, AnySymbolView symbolView, ITuple seed,
                                                         IQueryRuntimeContextListener listener) {
-                var relationViewUpdateListener = relationViewUpdateListeners.get(relationView);
-                relationViewUpdateListener.addFilter(key, seed, listener);
+                var symbolViewUpdateListener = symbolViewUpdateListeners.get(symbolView);
+                symbolViewUpdateListener.addFilter(key, seed, listener);
         }
 
-        public void removeListener(IInputKey key, AnyRelationView relationView, ITuple seed,
+        public void removeListener(IInputKey key, AnySymbolView symbolView, ITuple seed,
                                                            IQueryRuntimeContextListener listener) {
-                var relationViewUpdateListener = relationViewUpdateListeners.get(relationView);
-                relationViewUpdateListener.removeFilter(key, seed, listener);
+                var symbolViewUpdateListener = symbolViewUpdateListeners.get(symbolView);
+                symbolViewUpdateListener.removeFilter(key, seed, listener);
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/SymbolViewUpdateListener.java
index 185e4ebc..f1a2ac7c 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/RelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/SymbolViewUpdateListener.java
@@ -12,18 +12,18 @@ import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.model.InterpretationListener;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.RelationView;
-import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.query.view.SymbolView;
+import tools.refinery.store.query.view.TuplePreservingView;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public abstract class RelationViewUpdateListener<T> implements InterpretationListener<T> {
+public abstract class SymbolViewUpdateListener<T> implements InterpretationListener<T> {
         private final ViatraModelQueryAdapterImpl adapter;
         private final Interpretation<T> interpretation;
         private final List<RelationViewFilter> filters = new ArrayList<>();
 
-        protected RelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, Interpretation<T> interpretation) {
+        protected SymbolViewUpdateListener(ViatraModelQueryAdapterImpl adapter, Interpretation<T> interpretation) {
                 this.adapter = adapter;
                 this.interpretation = interpretation;
         }
@@ -53,13 +53,13 @@ public abstract class RelationViewUpdateListener<T> implements InterpretationLis
                 }
         }
 
-        public static <T> RelationViewUpdateListener<T> of(ViatraModelQueryAdapterImpl adapter,
-                                                                                                           RelationView<T> relationView,
-                                                                                                           Interpretation<T> interpretation) {
-                if (relationView instanceof TuplePreservingRelationView<T> tuplePreservingRelationView) {
-                        return new TuplePreservingRelationViewUpdateListener<>(adapter, tuplePreservingRelationView,
+        public static <T> SymbolViewUpdateListener<T> of(ViatraModelQueryAdapterImpl adapter,
+                                                                                                         SymbolView<T> view,
+                                                                                                         Interpretation<T> interpretation) {
+                if (view instanceof TuplePreservingView<T> tuplePreservingRelationView) {
+                        return new TuplePreservingViewUpdateListener<>(adapter, tuplePreservingRelationView,
                                         interpretation);
                 }
-                return new TupleChangingRelationViewUpdateListener<>(adapter, relationView, interpretation);
+                return new TupleChangingViewUpdateListener<>(adapter, view, interpretation);
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingViewUpdateListener.java
index be4951af..45d35571 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TupleChangingViewUpdateListener.java
@@ -8,37 +8,37 @@ package tools.refinery.store.query.viatra.internal.update;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.RelationView;
+import tools.refinery.store.query.view.SymbolView;
 import tools.refinery.store.tuple.Tuple;
 
 import java.util.Arrays;
 
-public class TupleChangingRelationViewUpdateListener<T> extends RelationViewUpdateListener<T> {
-        private final RelationView<T> relationView;
+public class TupleChangingViewUpdateListener<T> extends SymbolViewUpdateListener<T> {
+        private final SymbolView<T> view;
 
-        TupleChangingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter, RelationView<T> relationView,
-                                                                                        Interpretation<T> interpretation) {
+        TupleChangingViewUpdateListener(ViatraModelQueryAdapterImpl adapter, SymbolView<T> view,
+                                                                        Interpretation<T> interpretation) {
         super(adapter, interpretation);
-        this.relationView = relationView;
+        this.view = view;
         }
 
         @Override
         public void put(Tuple key, T fromValue, T toValue, boolean restoring) {
-                boolean fromPresent = relationView.filter(key, fromValue);
-                boolean toPresent = relationView.filter(key, toValue);
+                boolean fromPresent = view.filter(key, fromValue);
+                boolean toPresent = view.filter(key, toValue);
                 if (fromPresent) {
                         if (toPresent) { // value change
-                                var fromArray = relationView.forwardMap(key, fromValue);
-                                var toArray = relationView.forwardMap(key, toValue);
+                                var fromArray = view.forwardMap(key, fromValue);
+                                var toArray = view.forwardMap(key, toValue);
                                 if (!Arrays.equals(fromArray, toArray)) {
                                         processUpdate(Tuples.flatTupleOf(fromArray), false);
                                         processUpdate(Tuples.flatTupleOf(toArray), true);
                                 }
                         } else { // fromValue disappears
-                                processUpdate(Tuples.flatTupleOf(relationView.forwardMap(key, fromValue)), false);
+                                processUpdate(Tuples.flatTupleOf(view.forwardMap(key, fromValue)), false);
                         }
                 } else if (toPresent) { // toValue appears
-                        processUpdate(Tuples.flatTupleOf(relationView.forwardMap(key, toValue)), true);
+                        processUpdate(Tuples.flatTupleOf(view.forwardMap(key, toValue)), true);
                 }
         }
 }
diff --git a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingViewUpdateListener.java
index 9638266b..c18dbafb 100644
--- a/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingRelationViewUpdateListener.java
+++ b/subprojects/store-query-viatra/src/main/java/tools/refinery/store/query/viatra/internal/update/TuplePreservingViewUpdateListener.java
@@ -8,14 +8,14 @@ package tools.refinery.store.query.viatra.internal.update;
 import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
 import tools.refinery.store.model.Interpretation;
 import tools.refinery.store.query.viatra.internal.ViatraModelQueryAdapterImpl;
-import tools.refinery.store.query.view.TuplePreservingRelationView;
+import tools.refinery.store.query.view.TuplePreservingView;
 import tools.refinery.store.tuple.Tuple;
 
-public class TuplePreservingRelationViewUpdateListener<T> extends RelationViewUpdateListener<T> {
-        private final TuplePreservingRelationView<T> view;
+public class TuplePreservingViewUpdateListener<T> extends SymbolViewUpdateListener<T> {
+        private final TuplePreservingView<T> view;
 
-        TuplePreservingRelationViewUpdateListener(ViatraModelQueryAdapterImpl adapter,
-                                                                                          TuplePreservingRelationView<T> view, Interpretation<T> interpretation) {
+        TuplePreservingViewUpdateListener(ViatraModelQueryAdapterImpl adapter, TuplePreservingView<T> view,
+                                                                          Interpretation<T> interpretation) {
         super(adapter, interpretation);
         this.view = view;
         }