From b876d58edd3214906f94bf897e1fd6e9f7ac8734 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Tue, 17 Aug 2021 02:37:24 +0200 Subject: Views works as keys + they can be instantiated without model --- .../viatra/solver/data/query/RelationalQuery.java | 5 +- .../viatra/solver/data/query/RelationalScope.java | 7 +- .../query/internal/RelationUpdateListener.java | 6 +- .../internal/RelationUpdateListenerEntry.java | 5 +- .../data/query/internal/RelationViewKey.java | 60 ----------------- .../query/internal/RelationalEngineContext.java | 5 +- .../query/internal/RelationalQueryMetaContext.java | 7 +- .../query/internal/RelationalRuntimeContext.java | 32 +++++---- .../data/query/view/FilteredRelationView.java | 6 +- .../data/query/view/FunctionalRelationView.java | 6 +- .../solver/data/query/view/RelationView.java | 76 ++++++++++++++++------ .../viatra/solver/data/query/test/QueryTest.java | 4 +- 12 files changed, 100 insertions(+), 119 deletions(-) delete mode 100644 model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java index bbff5563..39fc2482 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/RelationalQuery.java @@ -10,9 +10,7 @@ import java.util.Set; import org.eclipse.viatra.query.runtime.api.GenericPatternMatcher; import org.eclipse.viatra.query.runtime.api.GenericQuerySpecification; -import org.eclipse.viatra.query.runtime.api.IQuerySpecification; import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine; -import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher; import org.eclipse.viatra.query.runtime.api.scope.QueryScope; import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint; import org.eclipse.viatra.query.runtime.matchers.psystem.PBody; @@ -27,7 +25,6 @@ import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.Positi import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint; import org.eclipse.viatra.query.runtime.matchers.psystem.queries.BasePQuery; import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameter; -import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PParameterDirection; import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery; import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PVisibility; import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples; @@ -80,7 +77,7 @@ public class RelationalQuery extends BasePQuery { for(int i = 0; i> relationViews) { + public RelationalScope(Model model, Set> relationViews) { + this.model = model; updateListener = new RelationUpdateListener(relationViews); } @@ -26,6 +29,6 @@ public class RelationalScope extends QueryScope{ @Override protected IEngineContext createEngineContext(ViatraQueryEngine engine, IIndexingErrorListener errorListener, Logger logger) { - return new RelationalEngineContext(this.updateListener); + return new RelationalEngineContext(model, updateListener); } } diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java index de814936..c6d12614 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListener.java @@ -19,18 +19,18 @@ public class RelationUpdateListener { view2Listeners.put(relationView, new HashSet<>()); } } - public boolean containsRelationalView(RelationViewKey relationalKey) { + public boolean containsRelationalView(RelationView relationalKey) { RelationView relationView = relationalKey.getWrappedKey(); return view2Listeners.containsKey(relationView); } - public void addListener(RelationViewKey relationalKey, ITuple seed, IQueryRuntimeContextListener listener) { + public void addListener(RelationView relationalKey, ITuple seed, IQueryRuntimeContextListener listener) { RelationView relationView = relationalKey.getWrappedKey(); if(view2Listeners.containsKey(relationView)) { RelationUpdateListenerEntry entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener); view2Listeners.get(relationView).add(entry); } else throw new IllegalArgumentException(); } - public void removeListener(RelationViewKey relationalKey, ITuple seed, IQueryRuntimeContextListener listener) { + public void removeListener(RelationView relationalKey, ITuple seed, IQueryRuntimeContextListener listener) { RelationView relationView = relationalKey.getWrappedKey(); if(view2Listeners.containsKey(relationView)) { RelationUpdateListenerEntry entry = new RelationUpdateListenerEntry<>(relationalKey, seed, listener); diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java index def02aa5..55aed7c8 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationUpdateListenerEntry.java @@ -7,13 +7,14 @@ import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContextLis import org.eclipse.viatra.query.runtime.matchers.tuple.ITuple; import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples; import org.eclipse.viatra.solver.data.model.Tuple; +import org.eclipse.viatra.solver.data.query.view.RelationView; public class RelationUpdateListenerEntry { - final RelationViewKey key; + final RelationView key; final ITuple filter; final IQueryRuntimeContextListener listener; - public RelationUpdateListenerEntry(RelationViewKey key, ITuple filter, IQueryRuntimeContextListener listener) { + public RelationUpdateListenerEntry(RelationView key, ITuple filter, IQueryRuntimeContextListener listener) { super(); this.key = key; this.filter = filter; diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java deleted file mode 100644 index bae0af45..00000000 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationViewKey.java +++ /dev/null @@ -1,60 +0,0 @@ -package org.eclipse.viatra.solver.data.query.internal; - -import java.util.Objects; -import java.util.UUID; - -import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper; -import org.eclipse.viatra.solver.data.query.view.RelationView; - -public class RelationViewKey extends BaseInputKeyWrapper>{ - private final String uniqueName; - private final int arity; - - public RelationViewKey(RelationView wrappedKey, int arity) { - super(wrappedKey); - this.uniqueName = wrappedKey.getRepresentation().getName() + "-"+UUID.randomUUID(); - this.arity = arity; - } - - @Override - public String getPrettyPrintableName() { - return wrappedKey.getRepresentation().getName(); - } - - @Override - public String getStringID() { - return uniqueName; - } - - @Override - public int getArity() { - return arity; - } - - @Override - public boolean isEnumerable() { - return true; - } - - @Override - public int hashCode() { - final int prime = 31; - int result = super.hashCode(); - result = prime * result + Objects.hash(uniqueName); - return result; - } - - @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (!super.equals(obj)) - return false; - if (!(obj instanceof RelationViewKey)) - return false; - RelationViewKey other = (RelationViewKey) obj; - return Objects.equals(uniqueName, other.uniqueName); - } - - -} diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java index c46da1bb..01948828 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalEngineContext.java @@ -3,14 +3,15 @@ package org.eclipse.viatra.solver.data.query.internal; import org.eclipse.viatra.query.runtime.api.scope.IBaseIndex; import org.eclipse.viatra.query.runtime.api.scope.IEngineContext; import org.eclipse.viatra.query.runtime.matchers.context.IQueryRuntimeContext; +import org.eclipse.viatra.solver.data.model.Model; public class RelationalEngineContext implements IEngineContext{ private final IBaseIndex baseIndex = new DummyBaseIndexer(); private final RelationalRuntimeContext runtimeContext; - public RelationalEngineContext(RelationUpdateListener updateListener) { - runtimeContext = new RelationalRuntimeContext(updateListener); + public RelationalEngineContext(Model model, RelationUpdateListener updateListener) { + runtimeContext = new RelationalRuntimeContext(model, updateListener); } @Override diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java index 457ed6fd..de500fc9 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalQueryMetaContext.java @@ -10,6 +10,7 @@ import java.util.Set; import org.eclipse.viatra.query.runtime.matchers.context.AbstractQueryMetaContext; import org.eclipse.viatra.query.runtime.matchers.context.IInputKey; import org.eclipse.viatra.query.runtime.matchers.context.InputKeyImplication; +import org.eclipse.viatra.solver.data.query.view.RelationView; /** * The meta context information for String scopes. @@ -25,7 +26,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext { @Override public boolean isStateless(IInputKey key) { ensureValidKey(key); - return key instanceof RelationViewKey; + return key instanceof RelationView; } @Override @@ -37,7 +38,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext { @Override public Map, Set> getFunctionalDependencies(IInputKey key) { ensureValidKey(key); - if (key instanceof RelationViewKey) { + if (key instanceof RelationView) { return new HashMap, Set>(); } else { return Collections.emptyMap(); @@ -45,7 +46,7 @@ public final class RelationalQueryMetaContext extends AbstractQueryMetaContext { } public void ensureValidKey(IInputKey key) { - if (! (key instanceof RelationViewKey)) + if (! (key instanceof RelationView)) illegalInputKey(key); } diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java index 8f6fb8dd..7d1682b2 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/internal/RelationalRuntimeContext.java @@ -19,12 +19,16 @@ import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple; import org.eclipse.viatra.query.runtime.matchers.tuple.TupleMask; import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples; import org.eclipse.viatra.query.runtime.matchers.util.Accuracy; +import org.eclipse.viatra.solver.data.model.Model; +import org.eclipse.viatra.solver.data.query.view.RelationView; public class RelationalRuntimeContext implements IQueryRuntimeContext { private final RelationalQueryMetaContext metaContext = new RelationalQueryMetaContext(); private final RelationUpdateListener relationUpdateListener; + private final Model model; - public RelationalRuntimeContext(RelationUpdateListener relationUpdateListener) { + public RelationalRuntimeContext(Model model, RelationUpdateListener relationUpdateListener) { + this.model = model; this.relationUpdateListener = relationUpdateListener; } @@ -53,8 +57,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext { @Override public boolean isIndexed(IInputKey key, IndexingService service) { - if(key instanceof RelationViewKey) { - RelationViewKey relationalKey = (RelationViewKey) key; + if(key instanceof RelationView) { + RelationView relationalKey = (RelationView) key; return this.relationUpdateListener.containsRelationalView(relationalKey); } else { return false; @@ -68,9 +72,9 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext { } } - RelationViewKey checkKey(IInputKey key) { - if(key instanceof RelationViewKey) { - RelationViewKey relationViewKey = (RelationViewKey) key; + RelationView checkKey(IInputKey key) { + if(key instanceof RelationView) { + RelationView relationViewKey = (RelationView) key; if(relationUpdateListener.containsRelationalView(relationViewKey)) { return relationViewKey; } else { @@ -83,8 +87,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext { @Override public int countTuples(IInputKey key, TupleMask seedMask, ITuple seed) { - RelationViewKey relationalViewKey = checkKey(key); - Iterable allObjects = relationalViewKey.getWrappedKey().getAll(); + RelationView relationalViewKey = checkKey(key); + Iterable allObjects = relationalViewKey.getAll(model); Iterable filteredBySeed = filter(allObjects,objectArray -> isMatching(objectArray,seedMask,seed)); Iterator iterator = filteredBySeed.iterator(); int result = 0; @@ -102,8 +106,8 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext { @Override public Iterable enumerateTuples(IInputKey key, TupleMask seedMask, ITuple seed) { - RelationViewKey relationalViewKey = checkKey(key); - Iterable allObjects = relationalViewKey.getWrappedKey().getAll(); + RelationView relationalViewKey = checkKey(key); + Iterable allObjects = relationalViewKey.getAll(model); Iterable filteredBySeed = filter(allObjects,objectArray -> isMatching(objectArray,seedMask,seed)); return map(filteredBySeed,Tuples::flatTupleOf); } @@ -134,20 +138,20 @@ public class RelationalRuntimeContext implements IQueryRuntimeContext { @Override public boolean containsTuple(IInputKey key, ITuple seed) { - RelationViewKey relationalViewKey = checkKey(key); - return relationalViewKey.getWrappedKey().get(seed.getElements()); + RelationView relationalViewKey = checkKey(key); + return relationalViewKey.get(model,seed.getElements()); } @Override public void addUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) { - RelationViewKey relationalKey = checkKey(key); + RelationView relationalKey = checkKey(key); this.relationUpdateListener.addListener(relationalKey, seed, listener); } @Override public void removeUpdateListener(IInputKey key, Tuple seed, IQueryRuntimeContextListener listener) { - RelationViewKey relationalKey = checkKey(key); + RelationView relationalKey = checkKey(key); this.relationUpdateListener.removeListener(relationalKey, seed, listener); } diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java index 4602af21..bfa3d13a 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/FilteredRelationView.java @@ -11,7 +11,7 @@ public class FilteredRelationView extends RelationView{ private final BiPredicate predicate; public FilteredRelationView(Model model, Relation representation, BiPredicate predicate) { - super(model, representation); + super(representation); this.predicate = predicate; } @Override @@ -19,13 +19,13 @@ public class FilteredRelationView extends RelationView{ return toTuple1Array(key); } @Override - public boolean get(Object[] tuple) { + public boolean get(Model model, Object[] tuple) { int[] content = new int[tuple.length]; for(int i = 0; i extends RelationView { public FunctionalRelationView(Model model, Relation representation) { - super(model, representation); + super(representation); } @Override @@ -22,7 +22,7 @@ public class FunctionalRelationView extends RelationView { } @Override - public boolean get(Object[] tuple) { + public boolean get(Model model, Object[] tuple) { int[] content = new int[tuple.length-1]; for(int i = 0; i extends RelationView { Tuple key = Tuple.of(content); @SuppressWarnings("unchecked") D valueInTuple = (D) tuple[tuple.length-1]; - D valueInMap = this.model.get(representation, key); + D valueInMap = model.get(representation, key); return valueInTuple.equals(valueInMap); } diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java index 18d2692d..c5bc5228 100644 --- a/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java +++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/query/view/RelationView.java @@ -1,51 +1,85 @@ package org.eclipse.viatra.solver.data.query.view; +import java.util.Objects; + +import org.eclipse.viatra.query.runtime.matchers.context.common.BaseInputKeyWrapper; import org.eclipse.viatra.solver.data.map.CursorAsIterator; import org.eclipse.viatra.solver.data.model.Model; import org.eclipse.viatra.solver.data.model.Tuple; import org.eclipse.viatra.solver.data.model.representation.Relation; -import org.eclipse.viatra.solver.data.query.internal.RelationViewKey; /** * Represents a view of a {@link Relation} that can be queried. + * * @author Oszkar Semerath * * @param */ -public abstract class RelationView{ - protected final Model model; +public abstract class RelationView extends BaseInputKeyWrapper> { protected final Relation representation; - private final RelationViewKey key; - - protected RelationView(Model model, Relation representation) { - this.model = model; + + protected RelationView(Relation representation) { + super(null); + this.wrappedKey = this; this.representation = representation; - key = new RelationViewKey<>(this, getArity()); } - - public Model getModel() { - return model; + + @Override + public String getPrettyPrintableName() { + return representation.getName(); + } + + @Override + public String getStringID() { + return representation.getName() + this.getClass().getName(); } + public Relation getRepresentation() { return representation; } - - public abstract int getArity(); + + @Override + public boolean isEnumerable() { + return true; + } + protected abstract boolean filter(Tuple key, D value); + protected abstract Object[] forwardMap(Tuple key, D value); - public abstract boolean get(Object[] tuple); + + public abstract boolean get(Model model, Object[] tuple); public Object[] transform(Tuple tuple, D value) { - if(filter(tuple, value)) { + if (filter(tuple, value)) { return forwardMap(tuple, value); - } else return null; + } else + return null; } - public Iterable getAll() { - return (()->new CursorAsIterator<>(model.getAll(representation), (k,v)->forwardMap(k,v), (k,v)->filter(k,v))); + public Iterable getAll(Model model) { + return (() -> new CursorAsIterator<>(model.getAll(representation), (k, v) -> forwardMap(k, v), + (k, v) -> filter(k, v))); } - - public RelationViewKey getKey() { - return key; + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + Objects.hash(representation); + return result; } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (!super.equals(obj)) + return false; + if (!(obj instanceof RelationView)) + return false; + @SuppressWarnings("unchecked") + RelationView other = ((RelationView) obj); + return Objects.equals(representation, other.representation); + } + } diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java index ca73b103..1e0c1d5c 100644 --- a/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java +++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/query/test/QueryTest.java @@ -39,7 +39,7 @@ class QueryTest { RelationView persionView = new TupleRelationView(model, person); - RelationalScope scope = new RelationalScope(Set.of(persionView)); + RelationalScope scope = new RelationalScope(model,Set.of(persionView)); GenericQuerySpecification personQuery = (new RelationalQuery("PersonQuery")) .addParameter("p", persionView).addConstraint(persionView, "p").build(); @@ -76,7 +76,7 @@ class QueryTest { (k, v) -> v.must()); RelationView friendMayView = new FilteredRelationView(model, friend, (k, v) -> v.may()); - RelationalScope scope = new RelationalScope(Set.of(persionView, ageView, friendMustView, friendMayView)); + RelationalScope scope = new RelationalScope(model,Set.of(persionView, ageView, friendMustView, friendMayView)); GenericQuerySpecification personQuery = (new RelationalQuery("PersonQuery")) .addParameter("p", persionView).addConstraint(persionView, "p").build(); -- cgit v1.2.3-70-g09d2