+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class ContentInNotLive extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private Dir fParent;
+
+ private FSObject fChild;
+
+ private static List parameterNames = makeImmutableList("parent", "child");
+
+ private Match(final Dir pParent, final FSObject pChild) {
+ this.fParent = pParent;
+ this.fChild = pChild;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "parent": return this.fParent;
+ case "child": return this.fChild;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fParent;
+ case 1: return this.fChild;
+ default: return null;
+ }
+ }
+
+ public Dir getParent() {
+ return this.fParent;
+ }
+
+ public FSObject getChild() {
+ return this.fChild;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("parent".equals(parameterName) ) {
+ this.fParent = (Dir) newValue;
+ return true;
+ }
+ if ("child".equals(parameterName) ) {
+ this.fChild = (FSObject) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setParent(final Dir pParent) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fParent = pParent;
+ }
+
+ public void setChild(final FSObject pChild) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fChild = pChild;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive";
+ }
+
+ @Override
+ public List parameterNames() {
+ return ContentInNotLive.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fParent, fChild};
+ }
+
+ @Override
+ public ContentInNotLive.Match toImmutable() {
+ return isMutable() ? newMatch(fParent, fChild) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"parent\"=" + prettyPrintValue(fParent) + ", ");
+ result.append("\"child\"=" + prettyPrintValue(fChild));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fParent, fChild);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof ContentInNotLive.Match)) {
+ ContentInNotLive.Match other = (ContentInNotLive.Match) obj;
+ return Objects.equals(fParent, other.fParent) && Objects.equals(fChild, other.fChild);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public ContentInNotLive specification() {
+ return ContentInNotLive.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static ContentInNotLive.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static ContentInNotLive.Match newMutableMatch(final Dir pParent, final FSObject pChild) {
+ return new Mutable(pParent, pChild);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static ContentInNotLive.Match newMatch(final Dir pParent, final FSObject pChild) {
+ return new Immutable(pParent, pChild);
+ }
+
+ private static final class Mutable extends ContentInNotLive.Match {
+ Mutable(final Dir pParent, final FSObject pChild) {
+ super(pParent, pChild);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends ContentInNotLive.Match {
+ Immutable(final Dir pParent, final FSObject pChild) {
+ super(pParent, pChild);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see ContentInNotLive
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static ContentInNotLive.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static ContentInNotLive.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_PARENT = 0;
+
+ private static final int POSITION_CHILD = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ContentInNotLive.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final Dir pParent, final FSObject pChild) {
+ return rawStreamAllMatches(new Object[]{pParent, pChild}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final Dir pParent, final FSObject pChild) {
+ return rawStreamAllMatches(new Object[]{pParent, pChild});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final Dir pParent, final FSObject pChild) {
+ return rawGetOneArbitraryMatch(new Object[]{pParent, pChild});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final Dir pParent, final FSObject pChild) {
+ return rawHasMatch(new Object[]{pParent, pChild});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final Dir pParent, final FSObject pChild) {
+ return rawCountMatches(new Object[]{pParent, pChild});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final Dir pParent, final FSObject pChild, final Consumer super ContentInNotLive.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pParent, pChild}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pParent the fixed value of pattern parameter parent, or null if not bound.
+ * @param pChild the fixed value of pattern parameter child, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public ContentInNotLive.Match newMatch(final Dir pParent, final FSObject pChild) {
+ return ContentInNotLive.Match.newMatch(pParent, pChild);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream
rawStreamAllValuesOfparent(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_PARENT, parameters).map(Dir.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfparent() {
+ return rawStreamAllValuesOfparent(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfparent() {
+ return rawStreamAllValuesOfparent(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfparent(final ContentInNotLive.Match partialMatch) {
+ return rawStreamAllValuesOfparent(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfparent(final FSObject pChild) {
+ return rawStreamAllValuesOfparent(new Object[]{null, pChild});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfparent(final ContentInNotLive.Match partialMatch) {
+ return rawStreamAllValuesOfparent(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for parent.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfparent(final FSObject pChild) {
+ return rawStreamAllValuesOfparent(new Object[]{null, pChild}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfchild(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_CHILD, parameters).map(FSObject.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfchild() {
+ return rawStreamAllValuesOfchild(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfchild() {
+ return rawStreamAllValuesOfchild(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfchild(final ContentInNotLive.Match partialMatch) {
+ return rawStreamAllValuesOfchild(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfchild(final Dir pParent) {
+ return rawStreamAllValuesOfchild(new Object[]{pParent, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfchild(final ContentInNotLive.Match partialMatch) {
+ return rawStreamAllValuesOfchild(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for child.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfchild(final Dir pParent) {
+ return rawStreamAllValuesOfchild(new Object[]{pParent, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected ContentInNotLive.Match tupleToMatch(final Tuple t) {
+ try {
+ return ContentInNotLive.Match.newMatch((Dir) t.get(POSITION_PARENT), (FSObject) t.get(POSITION_CHILD));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected ContentInNotLive.Match arrayToMatch(final Object[] match) {
+ try {
+ return ContentInNotLive.Match.newMatch((Dir) match[POSITION_PARENT], (FSObject) match[POSITION_CHILD]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected ContentInNotLive.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return ContentInNotLive.Match.newMutableMatch((Dir) match[POSITION_PARENT], (FSObject) match[POSITION_CHILD]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return ContentInNotLive.instance();
+ }
+ }
+
+ private ContentInNotLive() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static ContentInNotLive instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected ContentInNotLive.Matcher instantiate(final ViatraQueryEngine engine) {
+ return ContentInNotLive.Matcher.on(engine);
+ }
+
+ @Override
+ public ContentInNotLive.Matcher instantiate() {
+ return ContentInNotLive.Matcher.create();
+ }
+
+ @Override
+ public ContentInNotLive.Match newEmptyMatch() {
+ return ContentInNotLive.Match.newEmptyMatch();
+ }
+
+ @Override
+ public ContentInNotLive.Match newMatch(final Object... parameters) {
+ return ContentInNotLive.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.Dir) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link ContentInNotLive} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link ContentInNotLive#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final ContentInNotLive INSTANCE = new ContentInNotLive();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final ContentInNotLive.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_parent = new PParameter("parent", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.Dir", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "Dir")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_child = new PParameter("child", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_parent, parameter_child);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.contentInNotLive";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("parent","child");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_parent = body.getOrCreateVariableByName("parent");
+ PVariable var_child = body.getOrCreateVariableByName("child");
+ PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_child), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_parent, parameter_parent),
+ new ExportedParameter(body, var_child, parameter_child)
+ ));
+ // Dir.contents(parent,child)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "Dir", "contents")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ new Equality(body, var__virtual_0_, var_child);
+ // neg find live(_,parent)
+ new NegativePatternCall(body, Tuples.flatTupleOf(var___0_, var_parent), Live.instance().getInternalQueryRepresentation());
+ bodies.add(body);
+ }
+ {
+ PBody body = new PBody(this);
+ PVariable var_parent = body.getOrCreateVariableByName("parent");
+ PVariable var_child = body.getOrCreateVariableByName("child");
+ PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_child), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_parent, parameter_parent),
+ new ExportedParameter(body, var_child, parameter_child)
+ ));
+ // Dir.contents(parent,child)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_parent, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "Dir", "contents")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ new Equality(body, var__virtual_0_, var_child);
+ // neg find live(_,child)
+ new NegativePatternCall(body, Tuples.flatTupleOf(var___0_, var_child), Live.instance().getInternalQueryRepresentation());
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("child")
+ }));
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("message", "error");
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java
new file mode 100644
index 00000000..72c31e34
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/DirectSupertype.java
@@ -0,0 +1,703 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class DirectSupertype extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private EClass fA;
+
+ private EClass fB;
+
+ private static List parameterNames = makeImmutableList("a", "b");
+
+ private Match(final EClass pA, final EClass pB) {
+ this.fA = pA;
+ this.fB = pB;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "a": return this.fA;
+ case "b": return this.fB;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fA;
+ case 1: return this.fB;
+ default: return null;
+ }
+ }
+
+ public EClass getA() {
+ return this.fA;
+ }
+
+ public EClass getB() {
+ return this.fB;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("a".equals(parameterName) ) {
+ this.fA = (EClass) newValue;
+ return true;
+ }
+ if ("b".equals(parameterName) ) {
+ this.fB = (EClass) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setA(final EClass pA) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fA = pA;
+ }
+
+ public void setB(final EClass pB) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fB = pB;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype";
+ }
+
+ @Override
+ public List parameterNames() {
+ return DirectSupertype.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fA, fB};
+ }
+
+ @Override
+ public DirectSupertype.Match toImmutable() {
+ return isMutable() ? newMatch(fA, fB) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+ result.append("\"b\"=" + prettyPrintValue(fB));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fA, fB);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof DirectSupertype.Match)) {
+ DirectSupertype.Match other = (DirectSupertype.Match) obj;
+ return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public DirectSupertype specification() {
+ return DirectSupertype.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static DirectSupertype.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static DirectSupertype.Match newMutableMatch(final EClass pA, final EClass pB) {
+ return new Mutable(pA, pB);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {
+ return new Immutable(pA, pB);
+ }
+
+ private static final class Mutable extends DirectSupertype.Match {
+ Mutable(final EClass pA, final EClass pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends DirectSupertype.Match {
+ Immutable(final EClass pA, final EClass pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see DirectSupertype
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static DirectSupertype.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static DirectSupertype.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_A = 0;
+
+ private static final int POSITION_B = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(DirectSupertype.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final EClass pA, final EClass pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final EClass pA, final EClass pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final EClass pA, final EClass pB) {
+ return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final EClass pA, final EClass pB) {
+ return rawHasMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final EClass pA, final EClass pB) {
+ return rawCountMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final EClass pA, final EClass pB, final Consumer super DirectSupertype.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public DirectSupertype.Match newMatch(final EClass pA, final EClass pB) {
+ return DirectSupertype.Match.newMatch(pA, pB);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfa(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final DirectSupertype.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final EClass pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final DirectSupertype.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final EClass pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfb(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_B, parameters).map(EClass.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final DirectSupertype.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final EClass pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final DirectSupertype.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final EClass pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected DirectSupertype.Match tupleToMatch(final Tuple t) {
+ try {
+ return DirectSupertype.Match.newMatch((EClass) t.get(POSITION_A), (EClass) t.get(POSITION_B));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected DirectSupertype.Match arrayToMatch(final Object[] match) {
+ try {
+ return DirectSupertype.Match.newMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected DirectSupertype.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return DirectSupertype.Match.newMutableMatch((EClass) match[POSITION_A], (EClass) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return DirectSupertype.instance();
+ }
+ }
+
+ private DirectSupertype() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static DirectSupertype instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected DirectSupertype.Matcher instantiate(final ViatraQueryEngine engine) {
+ return DirectSupertype.Matcher.on(engine);
+ }
+
+ @Override
+ public DirectSupertype.Matcher instantiate() {
+ return DirectSupertype.Matcher.create();
+ }
+
+ @Override
+ public DirectSupertype.Match newEmptyMatch() {
+ return DirectSupertype.Match.newEmptyMatch();
+ }
+
+ @Override
+ public DirectSupertype.Match newMatch(final Object... parameters) {
+ return DirectSupertype.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0], (org.eclipse.emf.ecore.EClass) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link DirectSupertype} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link DirectSupertype#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final DirectSupertype INSTANCE = new DirectSupertype();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final DirectSupertype.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_a, parameter_b);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.directSupertype";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("a","b");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_a = body.getOrCreateVariableByName("a");
+ PVariable var_b = body.getOrCreateVariableByName("b");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_a, parameter_a),
+ new ExportedParameter(body, var_b, parameter_b)
+ ));
+ // EClass.eSuperTypes(a,b)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass", "eSuperTypes")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ new Equality(body, var__virtual_0_, var_b);
+ bodies.add(body);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java
new file mode 100644
index 00000000..3f2448aa
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Live.java
@@ -0,0 +1,741 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/FileSystem.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject;
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem;
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.PatternContent;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class Live extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private FileSystem fThis;
+
+ private FSObject fL;
+
+ private static List parameterNames = makeImmutableList("this", "l");
+
+ private Match(final FileSystem pThis, final FSObject pL) {
+ this.fThis = pThis;
+ this.fL = pL;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "this": return this.fThis;
+ case "l": return this.fL;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fThis;
+ case 1: return this.fL;
+ default: return null;
+ }
+ }
+
+ public FileSystem getThis() {
+ return this.fThis;
+ }
+
+ public FSObject getL() {
+ return this.fL;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("this".equals(parameterName) ) {
+ this.fThis = (FileSystem) newValue;
+ return true;
+ }
+ if ("l".equals(parameterName) ) {
+ this.fL = (FSObject) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setThis(final FileSystem pThis) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fThis = pThis;
+ }
+
+ public void setL(final FSObject pL) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fL = pL;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live";
+ }
+
+ @Override
+ public List parameterNames() {
+ return Live.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fThis, fL};
+ }
+
+ @Override
+ public Live.Match toImmutable() {
+ return isMutable() ? newMatch(fThis, fL) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"this\"=" + prettyPrintValue(fThis) + ", ");
+ result.append("\"l\"=" + prettyPrintValue(fL));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fThis, fL);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof Live.Match)) {
+ Live.Match other = (Live.Match) obj;
+ return Objects.equals(fThis, other.fThis) && Objects.equals(fL, other.fL);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public Live specification() {
+ return Live.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static Live.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static Live.Match newMutableMatch(final FileSystem pThis, final FSObject pL) {
+ return new Mutable(pThis, pL);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static Live.Match newMatch(final FileSystem pThis, final FSObject pL) {
+ return new Immutable(pThis, pL);
+ }
+
+ private static final class Mutable extends Live.Match {
+ Mutable(final FileSystem pThis, final FSObject pL) {
+ super(pThis, pL);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends Live.Match {
+ Immutable(final FileSystem pThis, final FSObject pL) {
+ super(pThis, pL);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see Live
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static Live.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static Live.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_THIS = 0;
+
+ private static final int POSITION_L = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Live.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final FileSystem pThis, final FSObject pL) {
+ return rawStreamAllMatches(new Object[]{pThis, pL}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final FileSystem pThis, final FSObject pL) {
+ return rawStreamAllMatches(new Object[]{pThis, pL});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final FileSystem pThis, final FSObject pL) {
+ return rawGetOneArbitraryMatch(new Object[]{pThis, pL});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final FileSystem pThis, final FSObject pL) {
+ return rawHasMatch(new Object[]{pThis, pL});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final FileSystem pThis, final FSObject pL) {
+ return rawCountMatches(new Object[]{pThis, pL});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final FileSystem pThis, final FSObject pL, final Consumer super Live.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pThis, pL}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pThis the fixed value of pattern parameter this, or null if not bound.
+ * @param pL the fixed value of pattern parameter l, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public Live.Match newMatch(final FileSystem pThis, final FSObject pL) {
+ return Live.Match.newMatch(pThis, pL);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfthis(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_THIS, parameters).map(FileSystem.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfthis() {
+ return rawStreamAllValuesOfthis(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfthis() {
+ return rawStreamAllValuesOfthis(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfthis(final Live.Match partialMatch) {
+ return rawStreamAllValuesOfthis(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfthis(final FSObject pL) {
+ return rawStreamAllValuesOfthis(new Object[]{null, pL});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfthis(final Live.Match partialMatch) {
+ return rawStreamAllValuesOfthis(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for this.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfthis(final FSObject pL) {
+ return rawStreamAllValuesOfthis(new Object[]{null, pL}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfl(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_L, parameters).map(FSObject.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfl() {
+ return rawStreamAllValuesOfl(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfl() {
+ return rawStreamAllValuesOfl(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfl(final Live.Match partialMatch) {
+ return rawStreamAllValuesOfl(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfl(final FileSystem pThis) {
+ return rawStreamAllValuesOfl(new Object[]{pThis, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfl(final Live.Match partialMatch) {
+ return rawStreamAllValuesOfl(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for l.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfl(final FileSystem pThis) {
+ return rawStreamAllValuesOfl(new Object[]{pThis, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected Live.Match tupleToMatch(final Tuple t) {
+ try {
+ return Live.Match.newMatch((FileSystem) t.get(POSITION_THIS), (FSObject) t.get(POSITION_L));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected Live.Match arrayToMatch(final Object[] match) {
+ try {
+ return Live.Match.newMatch((FileSystem) match[POSITION_THIS], (FSObject) match[POSITION_L]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected Live.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return Live.Match.newMutableMatch((FileSystem) match[POSITION_THIS], (FSObject) match[POSITION_L]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return Live.instance();
+ }
+ }
+
+ private Live() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static Live instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected Live.Matcher instantiate(final ViatraQueryEngine engine) {
+ return Live.Matcher.on(engine);
+ }
+
+ @Override
+ public Live.Matcher instantiate() {
+ return Live.Matcher.create();
+ }
+
+ @Override
+ public Live.Match newEmptyMatch() {
+ return Live.Match.newEmptyMatch();
+ }
+
+ @Override
+ public Live.Match newMatch(final Object... parameters) {
+ return Live.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link Live} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link Live#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final Live INSTANCE = new Live();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final Live.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_this = new PParameter("this", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FileSystem", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FileSystem")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_l = new PParameter("l", "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("FS", "FSObject")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_this, parameter_l);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.live";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("this","l");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_this = body.getOrCreateVariableByName("this");
+ PVariable var_l = body.getOrCreateVariableByName("l");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_l), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_this, parameter_this),
+ new ExportedParameter(body, var_l, parameter_l)
+ ));
+ // FileSystem.root(this,l)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "FileSystem", "root")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ new Equality(body, var__virtual_0_, var_l);
+ bodies.add(body);
+ }
+ {
+ PBody body = new PBody(this);
+ PVariable var_this = body.getOrCreateVariableByName("this");
+ PVariable var_l = body.getOrCreateVariableByName("l");
+ PVariable var_root = body.getOrCreateVariableByName("root");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_l), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FSObject")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_this, parameter_this),
+ new ExportedParameter(body, var_l, parameter_l)
+ ));
+ // FileSystem.root(this,root)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "FileSystem")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_this, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("FS", "FileSystem", "root")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("FS", "Dir")));
+ new Equality(body, var__virtual_0_, var_root);
+ // find patternContent+(root,l)
+ new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_root, var_l), PatternContent.instance().getInternalQueryRepresentation());
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("QueryBasedFeature");
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/LoopInInheritence.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/LoopInInheritence.java
new file mode 100644
index 00000000..f81b989c
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/LoopInInheritence.java
@@ -0,0 +1,558 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.DirectSupertype;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class LoopInInheritence extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private EClass fA;
+
+ private static List parameterNames = makeImmutableList("a");
+
+ private Match(final EClass pA) {
+ this.fA = pA;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "a": return this.fA;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fA;
+ default: return null;
+ }
+ }
+
+ public EClass getA() {
+ return this.fA;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("a".equals(parameterName) ) {
+ this.fA = (EClass) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setA(final EClass pA) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fA = pA;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence";
+ }
+
+ @Override
+ public List parameterNames() {
+ return LoopInInheritence.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fA};
+ }
+
+ @Override
+ public LoopInInheritence.Match toImmutable() {
+ return isMutable() ? newMatch(fA) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"a\"=" + prettyPrintValue(fA));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fA);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof LoopInInheritence.Match)) {
+ LoopInInheritence.Match other = (LoopInInheritence.Match) obj;
+ return Objects.equals(fA, other.fA);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public LoopInInheritence specification() {
+ return LoopInInheritence.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static LoopInInheritence.Match newEmptyMatch() {
+ return new Mutable(null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static LoopInInheritence.Match newMutableMatch(final EClass pA) {
+ return new Mutable(pA);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static LoopInInheritence.Match newMatch(final EClass pA) {
+ return new Immutable(pA);
+ }
+
+ private static final class Mutable extends LoopInInheritence.Match {
+ Mutable(final EClass pA) {
+ super(pA);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends LoopInInheritence.Match {
+ Immutable(final EClass pA) {
+ super(pA);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see LoopInInheritence
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static LoopInInheritence.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static LoopInInheritence.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_A = 0;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(LoopInInheritence.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final EClass pA) {
+ return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final EClass pA) {
+ return rawStreamAllMatches(new Object[]{pA});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final EClass pA) {
+ return rawGetOneArbitraryMatch(new Object[]{pA});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final EClass pA) {
+ return rawHasMatch(new Object[]{pA});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final EClass pA) {
+ return rawCountMatches(new Object[]{pA});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final EClass pA, final Consumer super LoopInInheritence.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pA}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public LoopInInheritence.Match newMatch(final EClass pA) {
+ return LoopInInheritence.Match.newMatch(pA);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfa(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_A, parameters).map(EClass.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray());
+ }
+
+ @Override
+ protected LoopInInheritence.Match tupleToMatch(final Tuple t) {
+ try {
+ return LoopInInheritence.Match.newMatch((EClass) t.get(POSITION_A));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected LoopInInheritence.Match arrayToMatch(final Object[] match) {
+ try {
+ return LoopInInheritence.Match.newMatch((EClass) match[POSITION_A]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected LoopInInheritence.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return LoopInInheritence.Match.newMutableMatch((EClass) match[POSITION_A]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return LoopInInheritence.instance();
+ }
+ }
+
+ private LoopInInheritence() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static LoopInInheritence instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected LoopInInheritence.Matcher instantiate(final ViatraQueryEngine engine) {
+ return LoopInInheritence.Matcher.on(engine);
+ }
+
+ @Override
+ public LoopInInheritence.Matcher instantiate() {
+ return LoopInInheritence.Matcher.create();
+ }
+
+ @Override
+ public LoopInInheritence.Match newEmptyMatch() {
+ return LoopInInheritence.Match.newEmptyMatch();
+ }
+
+ @Override
+ public LoopInInheritence.Match newMatch(final Object... parameters) {
+ return LoopInInheritence.Match.newMatch((org.eclipse.emf.ecore.EClass) parameters[0]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link LoopInInheritence} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link LoopInInheritence#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final LoopInInheritence INSTANCE = new LoopInInheritence();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final LoopInInheritence.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EClass", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EClass")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_a);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.loopInInheritence";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("a");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_a = body.getOrCreateVariableByName("a");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_a, parameter_a)
+ ));
+ // find directSupertype+(a,a)
+ new BinaryTransitiveClosure(body, Tuples.flatTupleOf(var_a, var_a), DirectSupertype.instance().getInternalQueryRepresentation());
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("a")
+ }));
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("message", "error");
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java
new file mode 100644
index 00000000..53725305
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/NonSymmetricOpposite.java
@@ -0,0 +1,718 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Opposite;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class NonSymmetricOpposite extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private EReference fA;
+
+ private EReference fB;
+
+ private static List parameterNames = makeImmutableList("a", "b");
+
+ private Match(final EReference pA, final EReference pB) {
+ this.fA = pA;
+ this.fB = pB;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "a": return this.fA;
+ case "b": return this.fB;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fA;
+ case 1: return this.fB;
+ default: return null;
+ }
+ }
+
+ public EReference getA() {
+ return this.fA;
+ }
+
+ public EReference getB() {
+ return this.fB;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("a".equals(parameterName) ) {
+ this.fA = (EReference) newValue;
+ return true;
+ }
+ if ("b".equals(parameterName) ) {
+ this.fB = (EReference) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setA(final EReference pA) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fA = pA;
+ }
+
+ public void setB(final EReference pB) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fB = pB;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite";
+ }
+
+ @Override
+ public List parameterNames() {
+ return NonSymmetricOpposite.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fA, fB};
+ }
+
+ @Override
+ public NonSymmetricOpposite.Match toImmutable() {
+ return isMutable() ? newMatch(fA, fB) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+ result.append("\"b\"=" + prettyPrintValue(fB));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fA, fB);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof NonSymmetricOpposite.Match)) {
+ NonSymmetricOpposite.Match other = (NonSymmetricOpposite.Match) obj;
+ return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public NonSymmetricOpposite specification() {
+ return NonSymmetricOpposite.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static NonSymmetricOpposite.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static NonSymmetricOpposite.Match newMutableMatch(final EReference pA, final EReference pB) {
+ return new Mutable(pA, pB);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {
+ return new Immutable(pA, pB);
+ }
+
+ private static final class Mutable extends NonSymmetricOpposite.Match {
+ Mutable(final EReference pA, final EReference pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends NonSymmetricOpposite.Match {
+ Immutable(final EReference pA, final EReference pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see NonSymmetricOpposite
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static NonSymmetricOpposite.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static NonSymmetricOpposite.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_A = 0;
+
+ private static final int POSITION_B = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NonSymmetricOpposite.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final EReference pA, final EReference pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final EReference pA, final EReference pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final EReference pA, final EReference pB) {
+ return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final EReference pA, final EReference pB) {
+ return rawHasMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final EReference pA, final EReference pB) {
+ return rawCountMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer super NonSymmetricOpposite.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public NonSymmetricOpposite.Match newMatch(final EReference pA, final EReference pB) {
+ return NonSymmetricOpposite.Match.newMatch(pA, pB);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfa(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final EReference pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final NonSymmetricOpposite.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final EReference pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfb(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final EReference pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final NonSymmetricOpposite.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final EReference pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected NonSymmetricOpposite.Match tupleToMatch(final Tuple t) {
+ try {
+ return NonSymmetricOpposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected NonSymmetricOpposite.Match arrayToMatch(final Object[] match) {
+ try {
+ return NonSymmetricOpposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected NonSymmetricOpposite.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return NonSymmetricOpposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return NonSymmetricOpposite.instance();
+ }
+ }
+
+ private NonSymmetricOpposite() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static NonSymmetricOpposite instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected NonSymmetricOpposite.Matcher instantiate(final ViatraQueryEngine engine) {
+ return NonSymmetricOpposite.Matcher.on(engine);
+ }
+
+ @Override
+ public NonSymmetricOpposite.Matcher instantiate() {
+ return NonSymmetricOpposite.Matcher.create();
+ }
+
+ @Override
+ public NonSymmetricOpposite.Match newEmptyMatch() {
+ return NonSymmetricOpposite.Match.newEmptyMatch();
+ }
+
+ @Override
+ public NonSymmetricOpposite.Match newMatch(final Object... parameters) {
+ return NonSymmetricOpposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link NonSymmetricOpposite} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link NonSymmetricOpposite#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final NonSymmetricOpposite INSTANCE = new NonSymmetricOpposite();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final NonSymmetricOpposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_a, parameter_b);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.nonSymmetricOpposite";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("a","b");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_a = body.getOrCreateVariableByName("a");
+ PVariable var_b = body.getOrCreateVariableByName("b");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_a, parameter_a),
+ new ExportedParameter(body, var_b, parameter_b)
+ ));
+ // find opposite(a,b)
+ new PositivePatternCall(body, Tuples.flatTupleOf(var_a, var_b), Opposite.instance().getInternalQueryRepresentation());
+ // neg find opposite(b,a)
+ new NegativePatternCall(body, Tuples.flatTupleOf(var_b, var_a), Opposite.instance().getInternalQueryRepresentation());
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("a")
+ }));
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("message", "error");
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java
new file mode 100644
index 00000000..7689d070
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Opposite.java
@@ -0,0 +1,704 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class Opposite extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private EReference fA;
+
+ private EReference fB;
+
+ private static List parameterNames = makeImmutableList("a", "b");
+
+ private Match(final EReference pA, final EReference pB) {
+ this.fA = pA;
+ this.fB = pB;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "a": return this.fA;
+ case "b": return this.fB;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fA;
+ case 1: return this.fB;
+ default: return null;
+ }
+ }
+
+ public EReference getA() {
+ return this.fA;
+ }
+
+ public EReference getB() {
+ return this.fB;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("a".equals(parameterName) ) {
+ this.fA = (EReference) newValue;
+ return true;
+ }
+ if ("b".equals(parameterName) ) {
+ this.fB = (EReference) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setA(final EReference pA) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fA = pA;
+ }
+
+ public void setB(final EReference pB) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fB = pB;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite";
+ }
+
+ @Override
+ public List parameterNames() {
+ return Opposite.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fA, fB};
+ }
+
+ @Override
+ public Opposite.Match toImmutable() {
+ return isMutable() ? newMatch(fA, fB) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"a\"=" + prettyPrintValue(fA) + ", ");
+ result.append("\"b\"=" + prettyPrintValue(fB));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fA, fB);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof Opposite.Match)) {
+ Opposite.Match other = (Opposite.Match) obj;
+ return Objects.equals(fA, other.fA) && Objects.equals(fB, other.fB);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public Opposite specification() {
+ return Opposite.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static Opposite.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static Opposite.Match newMutableMatch(final EReference pA, final EReference pB) {
+ return new Mutable(pA, pB);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static Opposite.Match newMatch(final EReference pA, final EReference pB) {
+ return new Immutable(pA, pB);
+ }
+
+ private static final class Mutable extends Opposite.Match {
+ Mutable(final EReference pA, final EReference pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends Opposite.Match {
+ Immutable(final EReference pA, final EReference pB) {
+ super(pA, pB);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see Opposite
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static Opposite.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static Opposite.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_A = 0;
+
+ private static final int POSITION_B = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(Opposite.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final EReference pA, final EReference pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final EReference pA, final EReference pB) {
+ return rawStreamAllMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final EReference pA, final EReference pB) {
+ return rawGetOneArbitraryMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final EReference pA, final EReference pB) {
+ return rawHasMatch(new Object[]{pA, pB});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final EReference pA, final EReference pB) {
+ return rawCountMatches(new Object[]{pA, pB});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final EReference pA, final EReference pB, final Consumer super Opposite.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pA, pB}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param pB the fixed value of pattern parameter b, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public Opposite.Match newMatch(final EReference pA, final EReference pB) {
+ return Opposite.Match.newMatch(pA, pB);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfa(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final Opposite.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa(final EReference pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final Opposite.Match partialMatch) {
+ return rawStreamAllValuesOfa(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa(final EReference pB) {
+ return rawStreamAllValuesOfa(new Object[]{null, pB}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfb(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_B, parameters).map(EReference.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb() {
+ return rawStreamAllValuesOfb(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final Opposite.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfb(final EReference pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final Opposite.Match partialMatch) {
+ return rawStreamAllValuesOfb(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for b.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfb(final EReference pA) {
+ return rawStreamAllValuesOfb(new Object[]{pA, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected Opposite.Match tupleToMatch(final Tuple t) {
+ try {
+ return Opposite.Match.newMatch((EReference) t.get(POSITION_A), (EReference) t.get(POSITION_B));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected Opposite.Match arrayToMatch(final Object[] match) {
+ try {
+ return Opposite.Match.newMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected Opposite.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return Opposite.Match.newMutableMatch((EReference) match[POSITION_A], (EReference) match[POSITION_B]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return Opposite.instance();
+ }
+ }
+
+ private Opposite() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static Opposite instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected Opposite.Matcher instantiate(final ViatraQueryEngine engine) {
+ return Opposite.Matcher.on(engine);
+ }
+
+ @Override
+ public Opposite.Matcher instantiate() {
+ return Opposite.Matcher.create();
+ }
+
+ @Override
+ public Opposite.Match newEmptyMatch() {
+ return Opposite.Match.newEmptyMatch();
+ }
+
+ @Override
+ public Opposite.Match newMatch(final Object... parameters) {
+ return Opposite.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0], (org.eclipse.emf.ecore.EReference) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link Opposite} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link Opposite#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final Opposite INSTANCE = new Opposite();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final Opposite.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_b = new PParameter("b", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_a, parameter_b);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.opposite";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("a","b");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_a = body.getOrCreateVariableByName("a");
+ PVariable var_b = body.getOrCreateVariableByName("b");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_a, parameter_a),
+ new ExportedParameter(body, var_b, parameter_b)
+ ));
+ // EReference.eOpposite(a,b)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ new Equality(body, var__virtual_0_, var_b);
+ bodies.add(body);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/OppositeDifferentClass.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/OppositeDifferentClass.java
new file mode 100644
index 00000000..aca12eca
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/OppositeDifferentClass.java
@@ -0,0 +1,587 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/Ecore.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class OppositeDifferentClass extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private EReference fA;
+
+ private static List parameterNames = makeImmutableList("a");
+
+ private Match(final EReference pA) {
+ this.fA = pA;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "a": return this.fA;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fA;
+ default: return null;
+ }
+ }
+
+ public EReference getA() {
+ return this.fA;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("a".equals(parameterName) ) {
+ this.fA = (EReference) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setA(final EReference pA) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fA = pA;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass";
+ }
+
+ @Override
+ public List parameterNames() {
+ return OppositeDifferentClass.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fA};
+ }
+
+ @Override
+ public OppositeDifferentClass.Match toImmutable() {
+ return isMutable() ? newMatch(fA) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"a\"=" + prettyPrintValue(fA));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fA);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof OppositeDifferentClass.Match)) {
+ OppositeDifferentClass.Match other = (OppositeDifferentClass.Match) obj;
+ return Objects.equals(fA, other.fA);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public OppositeDifferentClass specification() {
+ return OppositeDifferentClass.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static OppositeDifferentClass.Match newEmptyMatch() {
+ return new Mutable(null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static OppositeDifferentClass.Match newMutableMatch(final EReference pA) {
+ return new Mutable(pA);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static OppositeDifferentClass.Match newMatch(final EReference pA) {
+ return new Immutable(pA);
+ }
+
+ private static final class Mutable extends OppositeDifferentClass.Match {
+ Mutable(final EReference pA) {
+ super(pA);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends OppositeDifferentClass.Match {
+ Immutable(final EReference pA) {
+ super(pA);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see OppositeDifferentClass
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static OppositeDifferentClass.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static OppositeDifferentClass.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_A = 0;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(OppositeDifferentClass.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final EReference pA) {
+ return rawStreamAllMatches(new Object[]{pA}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final EReference pA) {
+ return rawStreamAllMatches(new Object[]{pA});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final EReference pA) {
+ return rawGetOneArbitraryMatch(new Object[]{pA});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final EReference pA) {
+ return rawHasMatch(new Object[]{pA});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final EReference pA) {
+ return rawCountMatches(new Object[]{pA});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final EReference pA, final Consumer super OppositeDifferentClass.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pA}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pA the fixed value of pattern parameter a, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public OppositeDifferentClass.Match newMatch(final EReference pA) {
+ return OppositeDifferentClass.Match.newMatch(pA);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfa(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_A, parameters).map(EReference.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for a.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfa() {
+ return rawStreamAllValuesOfa(emptyArray());
+ }
+
+ @Override
+ protected OppositeDifferentClass.Match tupleToMatch(final Tuple t) {
+ try {
+ return OppositeDifferentClass.Match.newMatch((EReference) t.get(POSITION_A));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected OppositeDifferentClass.Match arrayToMatch(final Object[] match) {
+ try {
+ return OppositeDifferentClass.Match.newMatch((EReference) match[POSITION_A]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected OppositeDifferentClass.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return OppositeDifferentClass.Match.newMutableMatch((EReference) match[POSITION_A]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return OppositeDifferentClass.instance();
+ }
+ }
+
+ private OppositeDifferentClass() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static OppositeDifferentClass instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected OppositeDifferentClass.Matcher instantiate(final ViatraQueryEngine engine) {
+ return OppositeDifferentClass.Matcher.on(engine);
+ }
+
+ @Override
+ public OppositeDifferentClass.Matcher instantiate() {
+ return OppositeDifferentClass.Matcher.create();
+ }
+
+ @Override
+ public OppositeDifferentClass.Match newEmptyMatch() {
+ return OppositeDifferentClass.Match.newEmptyMatch();
+ }
+
+ @Override
+ public OppositeDifferentClass.Match newMatch(final Object... parameters) {
+ return OppositeDifferentClass.Match.newMatch((org.eclipse.emf.ecore.EReference) parameters[0]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link OppositeDifferentClass} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link OppositeDifferentClass#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final OppositeDifferentClass INSTANCE = new OppositeDifferentClass();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final OppositeDifferentClass.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_a = new PParameter("a", "org.eclipse.emf.ecore.EReference", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.eclipse.org/emf/2002/Ecore", "EReference")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_a);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.oppositeDifferentClass";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("a");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_a = body.getOrCreateVariableByName("a");
+ PVariable var_b = body.getOrCreateVariableByName("b");
+ PVariable var_aContaining = body.getOrCreateVariableByName("aContaining");
+ PVariable var_bTarget = body.getOrCreateVariableByName("bTarget");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_a, parameter_a)
+ ));
+ // EReference.eOpposite(a,b)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference", "eOpposite")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ new Equality(body, var__virtual_0_, var_b);
+ // EReference.eContainingClass(a,aContaining)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_a, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "EStructuralFeature", "eContainingClass")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClass")));
+ new Equality(body, var__virtual_1_, var_aContaining);
+ // EReference.eType(b,bTarget)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_b), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EReference")));
+ PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_b, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.eclipse.org/emf/2002/Ecore", "ETypedElement", "eType")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EClassifier")));
+ new Equality(body, var__virtual_2_, var_bTarget);
+ // aContaining != bTarget
+ new Inequality(body, var_aContaining, var_bTarget);
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("a")
+ }));
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("message", "error");
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java
new file mode 100644
index 00000000..7c48b978
--- /dev/null
+++ b/Domains/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/src-gen/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/PatternContent.java
@@ -0,0 +1,704 @@
+/**
+ * Generated from platform:/resource/hu.bme.mit.inf.dslreasoner.domains.alloyexamples/patterns/hu/bme/mit/inf/dslreasoner/domains/alloyexamples/FileSystem.vql
+ */
+package hu.bme.mit.inf.dslreasoner.domains.alloyexamples;
+
+import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class PatternContent extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private FSObject fO1;
+
+ private FSObject fO2;
+
+ private static List parameterNames = makeImmutableList("o1", "o2");
+
+ private Match(final FSObject pO1, final FSObject pO2) {
+ this.fO1 = pO1;
+ this.fO2 = pO2;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "o1": return this.fO1;
+ case "o2": return this.fO2;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fO1;
+ case 1: return this.fO2;
+ default: return null;
+ }
+ }
+
+ public FSObject getO1() {
+ return this.fO1;
+ }
+
+ public FSObject getO2() {
+ return this.fO2;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("o1".equals(parameterName) ) {
+ this.fO1 = (FSObject) newValue;
+ return true;
+ }
+ if ("o2".equals(parameterName) ) {
+ this.fO2 = (FSObject) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setO1(final FSObject pO1) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fO1 = pO1;
+ }
+
+ public void setO2(final FSObject pO2) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fO2 = pO2;
+ }
+
+ @Override
+ public String patternName() {
+ return "hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent";
+ }
+
+ @Override
+ public List parameterNames() {
+ return PatternContent.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fO1, fO2};
+ }
+
+ @Override
+ public PatternContent.Match toImmutable() {
+ return isMutable() ? newMatch(fO1, fO2) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"o1\"=" + prettyPrintValue(fO1) + ", ");
+ result.append("\"o2\"=" + prettyPrintValue(fO2));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fO1, fO2);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof PatternContent.Match)) {
+ PatternContent.Match other = (PatternContent.Match) obj;
+ return Objects.equals(fO1, other.fO1) && Objects.equals(fO2, other.fO2);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public PatternContent specification() {
+ return PatternContent.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static PatternContent.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static PatternContent.Match newMutableMatch(final FSObject pO1, final FSObject pO2) {
+ return new Mutable(pO1, pO2);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static PatternContent.Match newMatch(final FSObject pO1, final FSObject pO2) {
+ return new Immutable(pO1, pO2);
+ }
+
+ private static final class Mutable extends PatternContent.Match {
+ Mutable(final FSObject pO1, final FSObject pO2) {
+ super(pO1, pO2);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends PatternContent.Match {
+ Immutable(final FSObject pO1, final FSObject pO2) {
+ super(pO1, pO2);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the hu.bme.mit.inf.dslreasoner.domains.alloyexamples.patternContent pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see PatternContent
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static PatternContent.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static PatternContent.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_O1 = 0;
+
+ private static final int POSITION_O2 = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(PatternContent.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final FSObject pO1, final FSObject pO2) {
+ return rawStreamAllMatches(new Object[]{pO1, pO2}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final FSObject pO1, final FSObject pO2) {
+ return rawStreamAllMatches(new Object[]{pO1, pO2});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final FSObject pO1, final FSObject pO2) {
+ return rawGetOneArbitraryMatch(new Object[]{pO1, pO2});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final FSObject pO1, final FSObject pO2) {
+ return rawHasMatch(new Object[]{pO1, pO2});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final FSObject pO1, final FSObject pO2) {
+ return rawCountMatches(new Object[]{pO1, pO2});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final FSObject pO1, final FSObject pO2, final Consumer super PatternContent.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pO1, pO2}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pO1 the fixed value of pattern parameter o1, or null if not bound.
+ * @param pO2 the fixed value of pattern parameter o2, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public PatternContent.Match newMatch(final FSObject pO1, final FSObject pO2) {
+ return PatternContent.Match.newMatch(pO1, pO2);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfo1(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_O1, parameters).map(FSObject.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo1() {
+ return rawStreamAllValuesOfo1(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo1() {
+ return rawStreamAllValuesOfo1(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo1(final PatternContent.Match partialMatch) {
+ return rawStreamAllValuesOfo1(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo1(final FSObject pO2) {
+ return rawStreamAllValuesOfo1(new Object[]{null, pO2});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo1(final PatternContent.Match partialMatch) {
+ return rawStreamAllValuesOfo1(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo1(final FSObject pO2) {
+ return rawStreamAllValuesOfo1(new Object[]{null, pO2}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfo2(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_O2, parameters).map(FSObject.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo2() {
+ return rawStreamAllValuesOfo2(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo2() {
+ return rawStreamAllValuesOfo2(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo2(final PatternContent.Match partialMatch) {
+ return rawStreamAllValuesOfo2(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfo2(final FSObject pO1) {
+ return rawStreamAllValuesOfo2(new Object[]{pO1, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo2(final PatternContent.Match partialMatch) {
+ return rawStreamAllValuesOfo2(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for o2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfo2(final FSObject pO1) {
+ return rawStreamAllValuesOfo2(new Object[]{pO1, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected PatternContent.Match tupleToMatch(final Tuple t) {
+ try {
+ return PatternContent.Match.newMatch((FSObject) t.get(POSITION_O1), (FSObject) t.get(POSITION_O2));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected PatternContent.Match arrayToMatch(final Object[] match) {
+ try {
+ return PatternContent.Match.newMatch((FSObject) match[POSITION_O1], (FSObject) match[POSITION_O2]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected PatternContent.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return PatternContent.Match.newMutableMatch((FSObject) match[POSITION_O1], (FSObject) match[POSITION_O2]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return PatternContent.instance();
+ }
+ }
+
+ private PatternContent() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static PatternContent instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected PatternContent.Matcher instantiate(final ViatraQueryEngine engine) {
+ return PatternContent.Matcher.on(engine);
+ }
+
+ @Override
+ public PatternContent.Matcher instantiate() {
+ return PatternContent.Matcher.create();
+ }
+
+ @Override
+ public PatternContent.Match newEmptyMatch() {
+ return PatternContent.Match.newEmptyMatch();
+ }
+
+ @Override
+ public PatternContent.Match newMatch(final Object... parameters) {
+ return PatternContent.Match.newMatch((hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[0], (hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FSObject) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link PatternContent} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link PatternContent#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final PatternContent INSTANCE = new PatternContent();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
Use the static instance as any {@link interface org.eclipse.viatra.query.runtime.api.IQueryGroup}, to conveniently prepare
- * a VIATRA Query engine for matching all patterns originally defined in file familyTreeConstraints.vql,
- * in order to achieve better performance than one-by-one on-demand matcher initialization.
- *
- *
From package queries, the group contains the definition of the following patterns:
- *
memberIsItsOwnParent
- *
twoMembersHaveNoParent
- *
memberHasParent
- *
parentTooYoung
- *
- *
- * @see IQueryGroup
- *
- */
-@SuppressWarnings("all")
-public final class FamilyTreeConstraints extends BaseGeneratedPatternGroup {
- /**
- * Access the pattern group.
- *
- * @return the singleton instance of the group
- * @throws ViatraQueryRuntimeException if there was an error loading the generated code of pattern specifications
- *
- */
- public static FamilyTreeConstraints instance() {
- if (INSTANCE == null) {
- INSTANCE = new FamilyTreeConstraints();
- }
- return INSTANCE;
- }
-
- private static FamilyTreeConstraints INSTANCE;
-
- private FamilyTreeConstraints() {
- querySpecifications.add(MemberIsItsOwnParent.instance());
- querySpecifications.add(TwoMembersHaveNoParent.instance());
- querySpecifications.add(MemberHasParent.instance());
- querySpecifications.add(ParentTooYoung.instance());
- }
-
- public MemberIsItsOwnParent getMemberIsItsOwnParent() {
- return MemberIsItsOwnParent.instance();
- }
-
- public MemberIsItsOwnParent.Matcher getMemberIsItsOwnParent(final ViatraQueryEngine engine) {
- return MemberIsItsOwnParent.Matcher.on(engine);
- }
-
- public TwoMembersHaveNoParent getTwoMembersHaveNoParent() {
- return TwoMembersHaveNoParent.instance();
- }
-
- public TwoMembersHaveNoParent.Matcher getTwoMembersHaveNoParent(final ViatraQueryEngine engine) {
- return TwoMembersHaveNoParent.Matcher.on(engine);
- }
-
- public MemberHasParent getMemberHasParent() {
- return MemberHasParent.instance();
- }
-
- public MemberHasParent.Matcher getMemberHasParent(final ViatraQueryEngine engine) {
- return MemberHasParent.Matcher.on(engine);
- }
-
- public ParentTooYoung getParentTooYoung() {
- return ParentTooYoung.instance();
- }
-
- public ParentTooYoung.Matcher getParentTooYoung(final ViatraQueryEngine engine) {
- return ParentTooYoung.Matcher.on(engine);
- }
-}
+/**
+ * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
+ */
+package queries;
+
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup;
+import queries.MemberHasParent;
+import queries.MemberIsItsOwnParent;
+import queries.ParentTooYoung;
+import queries.TwoMembersHaveNoParent;
+
+/**
+ * A pattern group formed of all public patterns defined in familyTreeConstraints.vql.
+ *
+ *
Use the static instance as any {@link interface org.eclipse.viatra.query.runtime.api.IQueryGroup}, to conveniently prepare
+ * a VIATRA Query engine for matching all patterns originally defined in file familyTreeConstraints.vql,
+ * in order to achieve better performance than one-by-one on-demand matcher initialization.
+ *
+ *
From package queries, the group contains the definition of the following patterns:
- *
- * @see Matcher
- * @see Match
- *
- */
-@SuppressWarnings("all")
-public final class MemberHasParent extends BaseGeneratedEMFQuerySpecification {
- /**
- * Pattern-specific match representation of the queries.memberHasParent pattern,
- * to be used in conjunction with {@link Matcher}.
- *
- *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
- * Each instance is a (possibly partial) substitution of pattern parameters,
- * usable to represent a match of the pattern in the result of a query,
- * or to specify the bound (fixed) input parameters when issuing a query.
- *
- * @see Matcher
- *
- */
- public static abstract class Match extends BasePatternMatch {
- private Member fM;
-
- private static List parameterNames = makeImmutableList("m");
-
- private Match(final Member pM) {
- this.fM = pM;
- }
-
- @Override
- public Object get(final String parameterName) {
- switch(parameterName) {
- case "m": return this.fM;
- default: return null;
- }
- }
-
- @Override
- public Object get(final int index) {
- switch(index) {
- case 0: return this.fM;
- default: return null;
- }
- }
-
- public Member getM() {
- return this.fM;
- }
-
- @Override
- public boolean set(final String parameterName, final Object newValue) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- if ("m".equals(parameterName) ) {
- this.fM = (Member) newValue;
- return true;
- }
- return false;
- }
-
- public void setM(final Member pM) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fM = pM;
- }
-
- @Override
- public String patternName() {
- return "queries.memberHasParent";
- }
-
- @Override
- public List parameterNames() {
- return MemberHasParent.Match.parameterNames;
- }
-
- @Override
- public Object[] toArray() {
- return new Object[]{fM};
- }
-
- @Override
- public MemberHasParent.Match toImmutable() {
- return isMutable() ? newMatch(fM) : this;
- }
-
- @Override
- public String prettyPrint() {
- StringBuilder result = new StringBuilder();
- result.append("\"m\"=" + prettyPrintValue(fM));
- return result.toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(fM);
- }
-
- @Override
- public boolean equals(final Object obj) {
- if (this == obj)
- return true;
- if (obj == null) {
- return false;
- }
- if ((obj instanceof MemberHasParent.Match)) {
- MemberHasParent.Match other = (MemberHasParent.Match) obj;
- return Objects.equals(fM, other.fM);
- } else {
- // this should be infrequent
- if (!(obj instanceof IPatternMatch)) {
- return false;
- }
- IPatternMatch otherSig = (IPatternMatch) obj;
- return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
- }
- }
-
- @Override
- public MemberHasParent specification() {
- return MemberHasParent.instance();
- }
-
- /**
- * Returns an empty, mutable match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @return the empty match.
- *
- */
- public static MemberHasParent.Match newEmptyMatch() {
- return new Mutable(null);
- }
-
- /**
- * Returns a mutable (partial) match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the new, mutable (partial) match object.
- *
- */
- public static MemberHasParent.Match newMutableMatch(final Member pM) {
- return new Mutable(pM);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public static MemberHasParent.Match newMatch(final Member pM) {
- return new Immutable(pM);
- }
-
- private static final class Mutable extends MemberHasParent.Match {
- Mutable(final Member pM) {
- super(pM);
- }
-
- @Override
- public boolean isMutable() {
- return true;
- }
- }
-
- private static final class Immutable extends MemberHasParent.Match {
- Immutable(final Member pM) {
- super(pM);
- }
-
- @Override
- public boolean isMutable() {
- return false;
- }
- }
- }
-
- /**
- * Generated pattern matcher API of the queries.memberHasParent pattern,
- * providing pattern-specific query methods.
- *
- *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
- * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
- *
- *
Matches of the pattern will be represented as {@link Match}.
- *
- *
- *
- * @see Match
- * @see MemberHasParent
- *
- */
- public static class Matcher extends BaseMatcher {
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- public static MemberHasParent.Matcher on(final ViatraQueryEngine engine) {
- // check if matcher already exists
- Matcher matcher = engine.getExistingMatcher(querySpecification());
- if (matcher == null) {
- matcher = (Matcher)engine.getMatcher(querySpecification());
- }
- return matcher;
- }
-
- /**
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- * @return an initialized matcher
- * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
- *
- */
- public static MemberHasParent.Matcher create() {
- return new Matcher();
- }
-
- private static final int POSITION_M = 0;
-
- private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(MemberHasParent.Matcher.class);
-
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- private Matcher() {
- super(querySpecification());
- }
-
- /**
- * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return matches represented as a Match object.
- *
- */
- public Collection getAllMatches(final Member pM) {
- return rawStreamAllMatches(new Object[]{pM}).collect(Collectors.toSet());
- }
-
- /**
- * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return a stream of matches represented as a Match object.
- *
- */
- public Stream streamAllMatches(final Member pM) {
- return rawStreamAllMatches(new Object[]{pM});
- }
-
- /**
- * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return a match represented as a Match object, or null if no match is found.
- *
- */
- public Optional getOneArbitraryMatch(final Member pM) {
- return rawGetOneArbitraryMatch(new Object[]{pM});
- }
-
- /**
- * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
- * under any possible substitution of the unspecified parameters (if any).
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return true if the input is a valid (partial) match of the pattern.
- *
- */
- public boolean hasMatch(final Member pM) {
- return rawHasMatch(new Object[]{pM});
- }
-
- /**
- * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the number of pattern matches found.
- *
- */
- public int countMatches(final Member pM) {
- return rawCountMatches(new Object[]{pM});
- }
-
- /**
- * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param processor the action that will process the selected match.
- * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
- *
- */
- public boolean forOneArbitraryMatch(final Member pM, final Consumer super MemberHasParent.Match> processor) {
- return rawForOneArbitraryMatch(new Object[]{pM}, processor);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public MemberHasParent.Match newMatch(final Member pM) {
- return MemberHasParent.Match.newMatch(pM);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
- return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray());
- }
-
- @Override
- protected MemberHasParent.Match tupleToMatch(final Tuple t) {
- try {
- return MemberHasParent.Match.newMatch((Member) t.get(POSITION_M));
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in tuple not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected MemberHasParent.Match arrayToMatch(final Object[] match) {
- try {
- return MemberHasParent.Match.newMatch((Member) match[POSITION_M]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected MemberHasParent.Match arrayToMatchMutable(final Object[] match) {
- try {
- return MemberHasParent.Match.newMutableMatch((Member) match[POSITION_M]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- /**
- * @return the singleton instance of the query specification of this pattern
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static IQuerySpecification querySpecification() {
- return MemberHasParent.instance();
- }
- }
-
- private MemberHasParent() {
- super(GeneratedPQuery.INSTANCE);
- }
-
- /**
- * @return the singleton instance of the query specification
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static MemberHasParent instance() {
- try{
- return LazyHolder.INSTANCE;
- } catch (ExceptionInInitializerError err) {
- throw processInitializerError(err);
- }
- }
-
- @Override
- protected MemberHasParent.Matcher instantiate(final ViatraQueryEngine engine) {
- return MemberHasParent.Matcher.on(engine);
- }
-
- @Override
- public MemberHasParent.Matcher instantiate() {
- return MemberHasParent.Matcher.create();
- }
-
- @Override
- public MemberHasParent.Match newEmptyMatch() {
- return MemberHasParent.Match.newEmptyMatch();
- }
-
- @Override
- public MemberHasParent.Match newMatch(final Object... parameters) {
- return MemberHasParent.Match.newMatch((familytree.Member) parameters[0]);
- }
-
- /**
- * Inner class allowing the singleton instance of {@link MemberHasParent} to be created
- * not at the class load time of the outer class,
- * but rather at the first call to {@link MemberHasParent#instance()}.
- *
- *
This workaround is required e.g. to support recursion.
- *
- */
- private static class LazyHolder {
- private static final MemberHasParent INSTANCE = new MemberHasParent();
-
- /**
- * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
- * This initialization order is required to support indirect recursion.
- *
- *
The static initializer is defined using a helper field to work around limitations of the code generator.
- *
- */
- private static final Object STATIC_INITIALIZER = ensureInitialized();
-
- public static Object ensureInitialized() {
- INSTANCE.ensureInitializedInternal();
- return null;
- }
- }
-
- private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
- private static final MemberHasParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
-
- private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final List parameters = Arrays.asList(parameter_m);
-
- private GeneratedPQuery() {
- super(PVisibility.PUBLIC);
- }
-
- @Override
- public String getFullyQualifiedName() {
- return "queries.memberHasParent";
- }
-
- @Override
- public List getParameterNames() {
- return Arrays.asList("m");
- }
-
- @Override
- public List getParameters() {
- return parameters;
- }
-
- @Override
- public Set doGetContainedBodies() {
- setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
- Set bodies = new LinkedHashSet<>();
- {
- PBody body = new PBody(this);
- PVariable var_m = body.getOrCreateVariableByName("m");
- PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- body.setSymbolicParameters(Arrays.asList(
- new ExportedParameter(body, var_m, parameter_m)
- ));
- // Member.parents(m, _)
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new Equality(body, var__virtual_0_, var___0_);
- bodies.add(body);
- }
- return bodies;
- }
- }
-}
+/**
+ * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
+ */
+package queries;
+
+import familytree.Member;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class MemberHasParent extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the queries.memberHasParent pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private Member fM;
+
+ private static List parameterNames = makeImmutableList("m");
+
+ private Match(final Member pM) {
+ this.fM = pM;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "m": return this.fM;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fM;
+ default: return null;
+ }
+ }
+
+ public Member getM() {
+ return this.fM;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("m".equals(parameterName) ) {
+ this.fM = (Member) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setM(final Member pM) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fM = pM;
+ }
+
+ @Override
+ public String patternName() {
+ return "queries.memberHasParent";
+ }
+
+ @Override
+ public List parameterNames() {
+ return MemberHasParent.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fM};
+ }
+
+ @Override
+ public MemberHasParent.Match toImmutable() {
+ return isMutable() ? newMatch(fM) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"m\"=" + prettyPrintValue(fM));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fM);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof MemberHasParent.Match)) {
+ MemberHasParent.Match other = (MemberHasParent.Match) obj;
+ return Objects.equals(fM, other.fM);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public MemberHasParent specification() {
+ return MemberHasParent.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static MemberHasParent.Match newEmptyMatch() {
+ return new Mutable(null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static MemberHasParent.Match newMutableMatch(final Member pM) {
+ return new Mutable(pM);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static MemberHasParent.Match newMatch(final Member pM) {
+ return new Immutable(pM);
+ }
+
+ private static final class Mutable extends MemberHasParent.Match {
+ Mutable(final Member pM) {
+ super(pM);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends MemberHasParent.Match {
+ Immutable(final Member pM) {
+ super(pM);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the queries.memberHasParent pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see MemberHasParent
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static MemberHasParent.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static MemberHasParent.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_M = 0;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(MemberHasParent.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final Member pM) {
+ return rawStreamAllMatches(new Object[]{pM}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final Member pM) {
+ return rawStreamAllMatches(new Object[]{pM});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final Member pM) {
+ return rawGetOneArbitraryMatch(new Object[]{pM});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final Member pM) {
+ return rawHasMatch(new Object[]{pM});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final Member pM) {
+ return rawCountMatches(new Object[]{pM});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final Member pM, final Consumer super MemberHasParent.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pM}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public MemberHasParent.Match newMatch(final Member pM) {
+ return MemberHasParent.Match.newMatch(pM);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray());
+ }
+
+ @Override
+ protected MemberHasParent.Match tupleToMatch(final Tuple t) {
+ try {
+ return MemberHasParent.Match.newMatch((Member) t.get(POSITION_M));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected MemberHasParent.Match arrayToMatch(final Object[] match) {
+ try {
+ return MemberHasParent.Match.newMatch((Member) match[POSITION_M]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected MemberHasParent.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return MemberHasParent.Match.newMutableMatch((Member) match[POSITION_M]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return MemberHasParent.instance();
+ }
+ }
+
+ private MemberHasParent() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static MemberHasParent instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected MemberHasParent.Matcher instantiate(final ViatraQueryEngine engine) {
+ return MemberHasParent.Matcher.on(engine);
+ }
+
+ @Override
+ public MemberHasParent.Matcher instantiate() {
+ return MemberHasParent.Matcher.create();
+ }
+
+ @Override
+ public MemberHasParent.Match newEmptyMatch() {
+ return MemberHasParent.Match.newEmptyMatch();
+ }
+
+ @Override
+ public MemberHasParent.Match newMatch(final Object... parameters) {
+ return MemberHasParent.Match.newMatch((familytree.Member) parameters[0]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link MemberHasParent} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link MemberHasParent#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final MemberHasParent INSTANCE = new MemberHasParent();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final MemberHasParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_m);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "queries.memberHasParent";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("m");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_m = body.getOrCreateVariableByName("m");
+ PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_m, parameter_m)
+ ));
+ // Member.parents(m, _)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new Equality(body, var__virtual_0_, var___0_);
+ bodies.add(body);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberIsItsOwnParent.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberIsItsOwnParent.java
index 67cdafb5..63cb882d 100644
--- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberIsItsOwnParent.java
+++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberIsItsOwnParent.java
@@ -1,577 +1,577 @@
-/**
- * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
- */
-package queries;
-
-import familytree.Member;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.apache.log4j.Logger;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.viatra.query.runtime.api.IPatternMatch;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
-import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
-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.PVisibility;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
-
-/**
- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
- *
- *
- *
- * @see Matcher
- * @see Match
- *
- */
-@SuppressWarnings("all")
-public final class MemberIsItsOwnParent extends BaseGeneratedEMFQuerySpecification {
- /**
- * Pattern-specific match representation of the queries.memberIsItsOwnParent pattern,
- * to be used in conjunction with {@link Matcher}.
- *
- *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
- * Each instance is a (possibly partial) substitution of pattern parameters,
- * usable to represent a match of the pattern in the result of a query,
- * or to specify the bound (fixed) input parameters when issuing a query.
- *
- * @see Matcher
- *
- */
- public static abstract class Match extends BasePatternMatch {
- private Member fM;
-
- private static List parameterNames = makeImmutableList("m");
-
- private Match(final Member pM) {
- this.fM = pM;
- }
-
- @Override
- public Object get(final String parameterName) {
- switch(parameterName) {
- case "m": return this.fM;
- default: return null;
- }
- }
-
- @Override
- public Object get(final int index) {
- switch(index) {
- case 0: return this.fM;
- default: return null;
- }
- }
-
- public Member getM() {
- return this.fM;
- }
-
- @Override
- public boolean set(final String parameterName, final Object newValue) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- if ("m".equals(parameterName) ) {
- this.fM = (Member) newValue;
- return true;
- }
- return false;
- }
-
- public void setM(final Member pM) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fM = pM;
- }
-
- @Override
- public String patternName() {
- return "queries.memberIsItsOwnParent";
- }
-
- @Override
- public List parameterNames() {
- return MemberIsItsOwnParent.Match.parameterNames;
- }
-
- @Override
- public Object[] toArray() {
- return new Object[]{fM};
- }
-
- @Override
- public MemberIsItsOwnParent.Match toImmutable() {
- return isMutable() ? newMatch(fM) : this;
- }
-
- @Override
- public String prettyPrint() {
- StringBuilder result = new StringBuilder();
- result.append("\"m\"=" + prettyPrintValue(fM));
- return result.toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(fM);
- }
-
- @Override
- public boolean equals(final Object obj) {
- if (this == obj)
- return true;
- if (obj == null) {
- return false;
- }
- if ((obj instanceof MemberIsItsOwnParent.Match)) {
- MemberIsItsOwnParent.Match other = (MemberIsItsOwnParent.Match) obj;
- return Objects.equals(fM, other.fM);
- } else {
- // this should be infrequent
- if (!(obj instanceof IPatternMatch)) {
- return false;
- }
- IPatternMatch otherSig = (IPatternMatch) obj;
- return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
- }
- }
-
- @Override
- public MemberIsItsOwnParent specification() {
- return MemberIsItsOwnParent.instance();
- }
-
- /**
- * Returns an empty, mutable match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @return the empty match.
- *
- */
- public static MemberIsItsOwnParent.Match newEmptyMatch() {
- return new Mutable(null);
- }
-
- /**
- * Returns a mutable (partial) match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the new, mutable (partial) match object.
- *
- */
- public static MemberIsItsOwnParent.Match newMutableMatch(final Member pM) {
- return new Mutable(pM);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public static MemberIsItsOwnParent.Match newMatch(final Member pM) {
- return new Immutable(pM);
- }
-
- private static final class Mutable extends MemberIsItsOwnParent.Match {
- Mutable(final Member pM) {
- super(pM);
- }
-
- @Override
- public boolean isMutable() {
- return true;
- }
- }
-
- private static final class Immutable extends MemberIsItsOwnParent.Match {
- Immutable(final Member pM) {
- super(pM);
- }
-
- @Override
- public boolean isMutable() {
- return false;
- }
- }
- }
-
- /**
- * Generated pattern matcher API of the queries.memberIsItsOwnParent pattern,
- * providing pattern-specific query methods.
- *
- *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
- * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
- *
- *
Matches of the pattern will be represented as {@link Match}.
- *
- *
- *
- * @see Match
- * @see MemberIsItsOwnParent
- *
- */
- public static class Matcher extends BaseMatcher {
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- public static MemberIsItsOwnParent.Matcher on(final ViatraQueryEngine engine) {
- // check if matcher already exists
- Matcher matcher = engine.getExistingMatcher(querySpecification());
- if (matcher == null) {
- matcher = (Matcher)engine.getMatcher(querySpecification());
- }
- return matcher;
- }
-
- /**
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- * @return an initialized matcher
- * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
- *
- */
- public static MemberIsItsOwnParent.Matcher create() {
- return new Matcher();
- }
-
- private static final int POSITION_M = 0;
-
- private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(MemberIsItsOwnParent.Matcher.class);
-
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- private Matcher() {
- super(querySpecification());
- }
-
- /**
- * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return matches represented as a Match object.
- *
- */
- public Collection getAllMatches(final Member pM) {
- return rawStreamAllMatches(new Object[]{pM}).collect(Collectors.toSet());
- }
-
- /**
- * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return a stream of matches represented as a Match object.
- *
- */
- public Stream streamAllMatches(final Member pM) {
- return rawStreamAllMatches(new Object[]{pM});
- }
-
- /**
- * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return a match represented as a Match object, or null if no match is found.
- *
- */
- public Optional getOneArbitraryMatch(final Member pM) {
- return rawGetOneArbitraryMatch(new Object[]{pM});
- }
-
- /**
- * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
- * under any possible substitution of the unspecified parameters (if any).
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return true if the input is a valid (partial) match of the pattern.
- *
- */
- public boolean hasMatch(final Member pM) {
- return rawHasMatch(new Object[]{pM});
- }
-
- /**
- * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the number of pattern matches found.
- *
- */
- public int countMatches(final Member pM) {
- return rawCountMatches(new Object[]{pM});
- }
-
- /**
- * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param processor the action that will process the selected match.
- * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
- *
- */
- public boolean forOneArbitraryMatch(final Member pM, final Consumer super MemberIsItsOwnParent.Match> processor) {
- return rawForOneArbitraryMatch(new Object[]{pM}, processor);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public MemberIsItsOwnParent.Match newMatch(final Member pM) {
- return MemberIsItsOwnParent.Match.newMatch(pM);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
- return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray());
- }
-
- @Override
- protected MemberIsItsOwnParent.Match tupleToMatch(final Tuple t) {
- try {
- return MemberIsItsOwnParent.Match.newMatch((Member) t.get(POSITION_M));
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in tuple not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected MemberIsItsOwnParent.Match arrayToMatch(final Object[] match) {
- try {
- return MemberIsItsOwnParent.Match.newMatch((Member) match[POSITION_M]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected MemberIsItsOwnParent.Match arrayToMatchMutable(final Object[] match) {
- try {
- return MemberIsItsOwnParent.Match.newMutableMatch((Member) match[POSITION_M]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- /**
- * @return the singleton instance of the query specification of this pattern
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static IQuerySpecification querySpecification() {
- return MemberIsItsOwnParent.instance();
- }
- }
-
- private MemberIsItsOwnParent() {
- super(GeneratedPQuery.INSTANCE);
- }
-
- /**
- * @return the singleton instance of the query specification
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static MemberIsItsOwnParent instance() {
- try{
- return LazyHolder.INSTANCE;
- } catch (ExceptionInInitializerError err) {
- throw processInitializerError(err);
- }
- }
-
- @Override
- protected MemberIsItsOwnParent.Matcher instantiate(final ViatraQueryEngine engine) {
- return MemberIsItsOwnParent.Matcher.on(engine);
- }
-
- @Override
- public MemberIsItsOwnParent.Matcher instantiate() {
- return MemberIsItsOwnParent.Matcher.create();
- }
-
- @Override
- public MemberIsItsOwnParent.Match newEmptyMatch() {
- return MemberIsItsOwnParent.Match.newEmptyMatch();
- }
-
- @Override
- public MemberIsItsOwnParent.Match newMatch(final Object... parameters) {
- return MemberIsItsOwnParent.Match.newMatch((familytree.Member) parameters[0]);
- }
-
- /**
- * Inner class allowing the singleton instance of {@link MemberIsItsOwnParent} to be created
- * not at the class load time of the outer class,
- * but rather at the first call to {@link MemberIsItsOwnParent#instance()}.
- *
- *
This workaround is required e.g. to support recursion.
- *
- */
- private static class LazyHolder {
- private static final MemberIsItsOwnParent INSTANCE = new MemberIsItsOwnParent();
-
- /**
- * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
- * This initialization order is required to support indirect recursion.
- *
- *
The static initializer is defined using a helper field to work around limitations of the code generator.
- *
- */
- private static final Object STATIC_INITIALIZER = ensureInitialized();
-
- public static Object ensureInitialized() {
- INSTANCE.ensureInitializedInternal();
- return null;
- }
- }
-
- private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
- private static final MemberIsItsOwnParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
-
- private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final List parameters = Arrays.asList(parameter_m);
-
- private GeneratedPQuery() {
- super(PVisibility.PUBLIC);
- }
-
- @Override
- public String getFullyQualifiedName() {
- return "queries.memberIsItsOwnParent";
- }
-
- @Override
- public List getParameterNames() {
- return Arrays.asList("m");
- }
-
- @Override
- public List getParameters() {
- return parameters;
- }
-
- @Override
- public Set doGetContainedBodies() {
- setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
- Set bodies = new LinkedHashSet<>();
- {
- PBody body = new PBody(this);
- PVariable var_m = body.getOrCreateVariableByName("m");
- PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
- PVariable var_p = body.getOrCreateVariableByName("p");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- body.setSymbolicParameters(Arrays.asList(
- new ExportedParameter(body, var_m, parameter_m)
- ));
- // FamilyTree.members(_, m)
- new TypeConstraint(body, Tuples.flatTupleOf(var___0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "FamilyTree")));
- PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
- new TypeConstraint(body, Tuples.flatTupleOf(var___0_, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "FamilyTree", "members")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new Equality(body, var__virtual_0_, var_m);
- // Member.parents(m, p)
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new Equality(body, var__virtual_1_, var_p);
- // m == p
- new Equality(body, var_m, var_p);
- bodies.add(body);
- }
- {
- PAnnotation annotation = new PAnnotation("Constraint");
- annotation.addAttribute("message", "memberIsItsOwnParent");
- annotation.addAttribute("severity", "error");
- annotation.addAttribute("key", Arrays.asList(new Object[] {
- new ParameterReference("m")
- }));
- addAnnotation(annotation);
- }
- return bodies;
- }
- }
-}
+/**
+ * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
+ */
+package queries;
+
+import familytree.Member;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class MemberIsItsOwnParent extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the queries.memberIsItsOwnParent pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private Member fM;
+
+ private static List parameterNames = makeImmutableList("m");
+
+ private Match(final Member pM) {
+ this.fM = pM;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "m": return this.fM;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fM;
+ default: return null;
+ }
+ }
+
+ public Member getM() {
+ return this.fM;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("m".equals(parameterName) ) {
+ this.fM = (Member) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setM(final Member pM) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fM = pM;
+ }
+
+ @Override
+ public String patternName() {
+ return "queries.memberIsItsOwnParent";
+ }
+
+ @Override
+ public List parameterNames() {
+ return MemberIsItsOwnParent.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fM};
+ }
+
+ @Override
+ public MemberIsItsOwnParent.Match toImmutable() {
+ return isMutable() ? newMatch(fM) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"m\"=" + prettyPrintValue(fM));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fM);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof MemberIsItsOwnParent.Match)) {
+ MemberIsItsOwnParent.Match other = (MemberIsItsOwnParent.Match) obj;
+ return Objects.equals(fM, other.fM);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public MemberIsItsOwnParent specification() {
+ return MemberIsItsOwnParent.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static MemberIsItsOwnParent.Match newEmptyMatch() {
+ return new Mutable(null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static MemberIsItsOwnParent.Match newMutableMatch(final Member pM) {
+ return new Mutable(pM);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static MemberIsItsOwnParent.Match newMatch(final Member pM) {
+ return new Immutable(pM);
+ }
+
+ private static final class Mutable extends MemberIsItsOwnParent.Match {
+ Mutable(final Member pM) {
+ super(pM);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends MemberIsItsOwnParent.Match {
+ Immutable(final Member pM) {
+ super(pM);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the queries.memberIsItsOwnParent pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see MemberIsItsOwnParent
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static MemberIsItsOwnParent.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static MemberIsItsOwnParent.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_M = 0;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(MemberIsItsOwnParent.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final Member pM) {
+ return rawStreamAllMatches(new Object[]{pM}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final Member pM) {
+ return rawStreamAllMatches(new Object[]{pM});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final Member pM) {
+ return rawGetOneArbitraryMatch(new Object[]{pM});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final Member pM) {
+ return rawHasMatch(new Object[]{pM});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final Member pM) {
+ return rawCountMatches(new Object[]{pM});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final Member pM, final Consumer super MemberIsItsOwnParent.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pM}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public MemberIsItsOwnParent.Match newMatch(final Member pM) {
+ return MemberIsItsOwnParent.Match.newMatch(pM);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray());
+ }
+
+ @Override
+ protected MemberIsItsOwnParent.Match tupleToMatch(final Tuple t) {
+ try {
+ return MemberIsItsOwnParent.Match.newMatch((Member) t.get(POSITION_M));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected MemberIsItsOwnParent.Match arrayToMatch(final Object[] match) {
+ try {
+ return MemberIsItsOwnParent.Match.newMatch((Member) match[POSITION_M]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected MemberIsItsOwnParent.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return MemberIsItsOwnParent.Match.newMutableMatch((Member) match[POSITION_M]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return MemberIsItsOwnParent.instance();
+ }
+ }
+
+ private MemberIsItsOwnParent() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static MemberIsItsOwnParent instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected MemberIsItsOwnParent.Matcher instantiate(final ViatraQueryEngine engine) {
+ return MemberIsItsOwnParent.Matcher.on(engine);
+ }
+
+ @Override
+ public MemberIsItsOwnParent.Matcher instantiate() {
+ return MemberIsItsOwnParent.Matcher.create();
+ }
+
+ @Override
+ public MemberIsItsOwnParent.Match newEmptyMatch() {
+ return MemberIsItsOwnParent.Match.newEmptyMatch();
+ }
+
+ @Override
+ public MemberIsItsOwnParent.Match newMatch(final Object... parameters) {
+ return MemberIsItsOwnParent.Match.newMatch((familytree.Member) parameters[0]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link MemberIsItsOwnParent} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link MemberIsItsOwnParent#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final MemberIsItsOwnParent INSTANCE = new MemberIsItsOwnParent();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final MemberIsItsOwnParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_m);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "queries.memberIsItsOwnParent";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("m");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_m = body.getOrCreateVariableByName("m");
+ PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+ PVariable var_p = body.getOrCreateVariableByName("p");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_m, parameter_m)
+ ));
+ // FamilyTree.members(_, m)
+ new TypeConstraint(body, Tuples.flatTupleOf(var___0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "FamilyTree")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var___0_, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "FamilyTree", "members")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new Equality(body, var__virtual_0_, var_m);
+ // Member.parents(m, p)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new Equality(body, var__virtual_1_, var_p);
+ // m == p
+ new Equality(body, var_m, var_p);
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("message", "memberIsItsOwnParent");
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("m")
+ }));
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java
index e90186e2..726ab7e4 100644
--- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java
+++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java
@@ -1,775 +1,775 @@
-/**
- * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
- */
-package queries;
-
-import familytree.Member;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.apache.log4j.Logger;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EDataType;
-import org.eclipse.viatra.query.runtime.api.IPatternMatch;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
-import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
-import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
-import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
-import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
-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.PVisibility;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
-
-/**
- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
- *
- *
- *
- * @see Matcher
- * @see Match
- *
- */
-@SuppressWarnings("all")
-public final class ParentTooYoung extends BaseGeneratedEMFQuerySpecification {
- /**
- * Pattern-specific match representation of the queries.parentTooYoung pattern,
- * to be used in conjunction with {@link Matcher}.
- *
- *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
- * Each instance is a (possibly partial) substitution of pattern parameters,
- * usable to represent a match of the pattern in the result of a query,
- * or to specify the bound (fixed) input parameters when issuing a query.
- *
- * @see Matcher
- *
- */
- public static abstract class Match extends BasePatternMatch {
- private Member fM;
-
- private Member fP;
-
- private static List parameterNames = makeImmutableList("m", "p");
-
- private Match(final Member pM, final Member pP) {
- this.fM = pM;
- this.fP = pP;
- }
-
- @Override
- public Object get(final String parameterName) {
- switch(parameterName) {
- case "m": return this.fM;
- case "p": return this.fP;
- default: return null;
- }
- }
-
- @Override
- public Object get(final int index) {
- switch(index) {
- case 0: return this.fM;
- case 1: return this.fP;
- default: return null;
- }
- }
-
- public Member getM() {
- return this.fM;
- }
-
- public Member getP() {
- return this.fP;
- }
-
- @Override
- public boolean set(final String parameterName, final Object newValue) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- if ("m".equals(parameterName) ) {
- this.fM = (Member) newValue;
- return true;
- }
- if ("p".equals(parameterName) ) {
- this.fP = (Member) newValue;
- return true;
- }
- return false;
- }
-
- public void setM(final Member pM) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fM = pM;
- }
-
- public void setP(final Member pP) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fP = pP;
- }
-
- @Override
- public String patternName() {
- return "queries.parentTooYoung";
- }
-
- @Override
- public List parameterNames() {
- return ParentTooYoung.Match.parameterNames;
- }
-
- @Override
- public Object[] toArray() {
- return new Object[]{fM, fP};
- }
-
- @Override
- public ParentTooYoung.Match toImmutable() {
- return isMutable() ? newMatch(fM, fP) : this;
- }
-
- @Override
- public String prettyPrint() {
- StringBuilder result = new StringBuilder();
- result.append("\"m\"=" + prettyPrintValue(fM) + ", ");
- result.append("\"p\"=" + prettyPrintValue(fP));
- return result.toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(fM, fP);
- }
-
- @Override
- public boolean equals(final Object obj) {
- if (this == obj)
- return true;
- if (obj == null) {
- return false;
- }
- if ((obj instanceof ParentTooYoung.Match)) {
- ParentTooYoung.Match other = (ParentTooYoung.Match) obj;
- return Objects.equals(fM, other.fM) && Objects.equals(fP, other.fP);
- } else {
- // this should be infrequent
- if (!(obj instanceof IPatternMatch)) {
- return false;
- }
- IPatternMatch otherSig = (IPatternMatch) obj;
- return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
- }
- }
-
- @Override
- public ParentTooYoung specification() {
- return ParentTooYoung.instance();
- }
-
- /**
- * Returns an empty, mutable match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @return the empty match.
- *
- */
- public static ParentTooYoung.Match newEmptyMatch() {
- return new Mutable(null, null);
- }
-
- /**
- * Returns a mutable (partial) match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return the new, mutable (partial) match object.
- *
- */
- public static ParentTooYoung.Match newMutableMatch(final Member pM, final Member pP) {
- return new Mutable(pM, pP);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public static ParentTooYoung.Match newMatch(final Member pM, final Member pP) {
- return new Immutable(pM, pP);
- }
-
- private static final class Mutable extends ParentTooYoung.Match {
- Mutable(final Member pM, final Member pP) {
- super(pM, pP);
- }
-
- @Override
- public boolean isMutable() {
- return true;
- }
- }
-
- private static final class Immutable extends ParentTooYoung.Match {
- Immutable(final Member pM, final Member pP) {
- super(pM, pP);
- }
-
- @Override
- public boolean isMutable() {
- return false;
- }
- }
- }
-
- /**
- * Generated pattern matcher API of the queries.parentTooYoung pattern,
- * providing pattern-specific query methods.
- *
- *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
- * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
- *
- *
Matches of the pattern will be represented as {@link Match}.
- *
- *
- *
- * @see Match
- * @see ParentTooYoung
- *
- */
- public static class Matcher extends BaseMatcher {
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- public static ParentTooYoung.Matcher on(final ViatraQueryEngine engine) {
- // check if matcher already exists
- Matcher matcher = engine.getExistingMatcher(querySpecification());
- if (matcher == null) {
- matcher = (Matcher)engine.getMatcher(querySpecification());
- }
- return matcher;
- }
-
- /**
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- * @return an initialized matcher
- * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
- *
- */
- public static ParentTooYoung.Matcher create() {
- return new Matcher();
- }
-
- private static final int POSITION_M = 0;
-
- private static final int POSITION_P = 1;
-
- private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ParentTooYoung.Matcher.class);
-
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- private Matcher() {
- super(querySpecification());
- }
-
- /**
- * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return matches represented as a Match object.
- *
- */
- public Collection getAllMatches(final Member pM, final Member pP) {
- return rawStreamAllMatches(new Object[]{pM, pP}).collect(Collectors.toSet());
- }
-
- /**
- * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return a stream of matches represented as a Match object.
- *
- */
- public Stream streamAllMatches(final Member pM, final Member pP) {
- return rawStreamAllMatches(new Object[]{pM, pP});
- }
-
- /**
- * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return a match represented as a Match object, or null if no match is found.
- *
- */
- public Optional getOneArbitraryMatch(final Member pM, final Member pP) {
- return rawGetOneArbitraryMatch(new Object[]{pM, pP});
- }
-
- /**
- * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
- * under any possible substitution of the unspecified parameters (if any).
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return true if the input is a valid (partial) match of the pattern.
- *
- */
- public boolean hasMatch(final Member pM, final Member pP) {
- return rawHasMatch(new Object[]{pM, pP});
- }
-
- /**
- * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return the number of pattern matches found.
- *
- */
- public int countMatches(final Member pM, final Member pP) {
- return rawCountMatches(new Object[]{pM, pP});
- }
-
- /**
- * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @param processor the action that will process the selected match.
- * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
- *
- */
- public boolean forOneArbitraryMatch(final Member pM, final Member pP, final Consumer super ParentTooYoung.Match> processor) {
- return rawForOneArbitraryMatch(new Object[]{pM, pP}, processor);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM the fixed value of pattern parameter m, or null if not bound.
- * @param pP the fixed value of pattern parameter p, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public ParentTooYoung.Match newMatch(final Member pM, final Member pP) {
- return ParentTooYoung.Match.newMatch(pM, pP);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
- return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm() {
- return rawStreamAllValuesOfm(emptyArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm(final ParentTooYoung.Match partialMatch) {
- return rawStreamAllValuesOfm(partialMatch.toArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm(final Member pP) {
- return rawStreamAllValuesOfm(new Object[]{null, pP});
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm(final ParentTooYoung.Match partialMatch) {
- return rawStreamAllValuesOfm(partialMatch.toArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm(final Member pP) {
- return rawStreamAllValuesOfm(new Object[]{null, pP}).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfp(final Object[] parameters) {
- return rawStreamAllValues(POSITION_P, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfp() {
- return rawStreamAllValuesOfp(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfp() {
- return rawStreamAllValuesOfp(emptyArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfp(final ParentTooYoung.Match partialMatch) {
- return rawStreamAllValuesOfp(partialMatch.toArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfp(final Member pM) {
- return rawStreamAllValuesOfp(new Object[]{pM, null});
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfp(final ParentTooYoung.Match partialMatch) {
- return rawStreamAllValuesOfp(partialMatch.toArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for p.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfp(final Member pM) {
- return rawStreamAllValuesOfp(new Object[]{pM, null}).collect(Collectors.toSet());
- }
-
- @Override
- protected ParentTooYoung.Match tupleToMatch(final Tuple t) {
- try {
- return ParentTooYoung.Match.newMatch((Member) t.get(POSITION_M), (Member) t.get(POSITION_P));
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in tuple not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected ParentTooYoung.Match arrayToMatch(final Object[] match) {
- try {
- return ParentTooYoung.Match.newMatch((Member) match[POSITION_M], (Member) match[POSITION_P]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected ParentTooYoung.Match arrayToMatchMutable(final Object[] match) {
- try {
- return ParentTooYoung.Match.newMutableMatch((Member) match[POSITION_M], (Member) match[POSITION_P]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- /**
- * @return the singleton instance of the query specification of this pattern
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static IQuerySpecification querySpecification() {
- return ParentTooYoung.instance();
- }
- }
-
- private ParentTooYoung() {
- super(GeneratedPQuery.INSTANCE);
- }
-
- /**
- * @return the singleton instance of the query specification
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static ParentTooYoung instance() {
- try{
- return LazyHolder.INSTANCE;
- } catch (ExceptionInInitializerError err) {
- throw processInitializerError(err);
- }
- }
-
- @Override
- protected ParentTooYoung.Matcher instantiate(final ViatraQueryEngine engine) {
- return ParentTooYoung.Matcher.on(engine);
- }
-
- @Override
- public ParentTooYoung.Matcher instantiate() {
- return ParentTooYoung.Matcher.create();
- }
-
- @Override
- public ParentTooYoung.Match newEmptyMatch() {
- return ParentTooYoung.Match.newEmptyMatch();
- }
-
- @Override
- public ParentTooYoung.Match newMatch(final Object... parameters) {
- return ParentTooYoung.Match.newMatch((familytree.Member) parameters[0], (familytree.Member) parameters[1]);
- }
-
- /**
- * Inner class allowing the singleton instance of {@link ParentTooYoung} to be created
- * not at the class load time of the outer class,
- * but rather at the first call to {@link ParentTooYoung#instance()}.
- *
- *
This workaround is required e.g. to support recursion.
- *
- */
- private static class LazyHolder {
- private static final ParentTooYoung INSTANCE = new ParentTooYoung();
-
- /**
- * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
- * This initialization order is required to support indirect recursion.
- *
- *
The static initializer is defined using a helper field to work around limitations of the code generator.
- *
- */
- private static final Object STATIC_INITIALIZER = ensureInitialized();
-
- public static Object ensureInitialized() {
- INSTANCE.ensureInitializedInternal();
- return null;
- }
- }
-
- private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
- private static final ParentTooYoung.GeneratedPQuery INSTANCE = new GeneratedPQuery();
-
- private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final PParameter parameter_p = new PParameter("p", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final List parameters = Arrays.asList(parameter_m, parameter_p);
-
- private GeneratedPQuery() {
- super(PVisibility.PUBLIC);
- }
-
- @Override
- public String getFullyQualifiedName() {
- return "queries.parentTooYoung";
- }
-
- @Override
- public List getParameterNames() {
- return Arrays.asList("m","p");
- }
-
- @Override
- public List getParameters() {
- return parameters;
- }
-
- @Override
- public Set doGetContainedBodies() {
- setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
- Set bodies = new LinkedHashSet<>();
- {
- PBody body = new PBody(this);
- PVariable var_m = body.getOrCreateVariableByName("m");
- PVariable var_p = body.getOrCreateVariableByName("p");
- PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
- PVariable var_mAge = body.getOrCreateVariableByName("mAge");
- PVariable var_pAge = body.getOrCreateVariableByName("pAge");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- body.setSymbolicParameters(Arrays.asList(
- new ExportedParameter(body, var_m, parameter_m),
- new ExportedParameter(body, var_p, parameter_p)
- ));
- // FamilyTree.members(_, m)
- new TypeConstraint(body, Tuples.flatTupleOf(var___0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "FamilyTree")));
- PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
- new TypeConstraint(body, Tuples.flatTupleOf(var___0_, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "FamilyTree", "members")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new Equality(body, var__virtual_0_, var_m);
- // Member.parents(m, p)
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new Equality(body, var__virtual_1_, var_p);
- // Member.age(m, mAge)
- new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
- new Equality(body, var__virtual_2_, var_mAge);
- // Member.age(p, pAge)
- new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
- new TypeConstraint(body, Tuples.flatTupleOf(var_p, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age")));
- new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
- new Equality(body, var__virtual_3_, var_pAge);
- // check (mAge <= (pAge + 12))
- new ExpressionEvaluation(body, new IExpressionEvaluator() {
-
- @Override
- public String getShortDescription() {
- return "Expression evaluation from pattern parentTooYoung";
- }
-
- @Override
- public Iterable getInputParameterNames() {
- return Arrays.asList("mAge", "pAge");}
-
- @Override
- public Object evaluateExpression(IValueProvider provider) throws Exception {
- Integer mAge = (Integer) provider.getValue("mAge");
- Integer pAge = (Integer) provider.getValue("pAge");
- return evaluateExpression_1_1(mAge, pAge);
- }
- }, null);
- bodies.add(body);
- }
- {
- PAnnotation annotation = new PAnnotation("Constraint");
- annotation.addAttribute("message", "parentTooYoung");
- annotation.addAttribute("severity", "error");
- annotation.addAttribute("key", Arrays.asList(new Object[] {
- new ParameterReference("m"),
- new ParameterReference("p")
- }));
- addAnnotation(annotation);
- }
- return bodies;
- }
- }
-
- private static boolean evaluateExpression_1_1(final Integer mAge, final Integer pAge) {
- return ((mAge).intValue() <= ((pAge).intValue() + 12));
- }
-}
+/**
+ * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
+ */
+package queries;
+
+import familytree.Member;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EDataType;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey;
+import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IExpressionEvaluator;
+import org.eclipse.viatra.query.runtime.matchers.psystem.IValueProvider;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExpressionEvaluation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class ParentTooYoung extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the queries.parentTooYoung pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private Member fM;
+
+ private Member fP;
+
+ private static List parameterNames = makeImmutableList("m", "p");
+
+ private Match(final Member pM, final Member pP) {
+ this.fM = pM;
+ this.fP = pP;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "m": return this.fM;
+ case "p": return this.fP;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fM;
+ case 1: return this.fP;
+ default: return null;
+ }
+ }
+
+ public Member getM() {
+ return this.fM;
+ }
+
+ public Member getP() {
+ return this.fP;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("m".equals(parameterName) ) {
+ this.fM = (Member) newValue;
+ return true;
+ }
+ if ("p".equals(parameterName) ) {
+ this.fP = (Member) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setM(final Member pM) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fM = pM;
+ }
+
+ public void setP(final Member pP) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fP = pP;
+ }
+
+ @Override
+ public String patternName() {
+ return "queries.parentTooYoung";
+ }
+
+ @Override
+ public List parameterNames() {
+ return ParentTooYoung.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fM, fP};
+ }
+
+ @Override
+ public ParentTooYoung.Match toImmutable() {
+ return isMutable() ? newMatch(fM, fP) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"m\"=" + prettyPrintValue(fM) + ", ");
+ result.append("\"p\"=" + prettyPrintValue(fP));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fM, fP);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof ParentTooYoung.Match)) {
+ ParentTooYoung.Match other = (ParentTooYoung.Match) obj;
+ return Objects.equals(fM, other.fM) && Objects.equals(fP, other.fP);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public ParentTooYoung specification() {
+ return ParentTooYoung.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static ParentTooYoung.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static ParentTooYoung.Match newMutableMatch(final Member pM, final Member pP) {
+ return new Mutable(pM, pP);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static ParentTooYoung.Match newMatch(final Member pM, final Member pP) {
+ return new Immutable(pM, pP);
+ }
+
+ private static final class Mutable extends ParentTooYoung.Match {
+ Mutable(final Member pM, final Member pP) {
+ super(pM, pP);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends ParentTooYoung.Match {
+ Immutable(final Member pM, final Member pP) {
+ super(pM, pP);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the queries.parentTooYoung pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see ParentTooYoung
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static ParentTooYoung.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static ParentTooYoung.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_M = 0;
+
+ private static final int POSITION_P = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ParentTooYoung.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final Member pM, final Member pP) {
+ return rawStreamAllMatches(new Object[]{pM, pP}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final Member pM, final Member pP) {
+ return rawStreamAllMatches(new Object[]{pM, pP});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final Member pM, final Member pP) {
+ return rawGetOneArbitraryMatch(new Object[]{pM, pP});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final Member pM, final Member pP) {
+ return rawHasMatch(new Object[]{pM, pP});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final Member pM, final Member pP) {
+ return rawCountMatches(new Object[]{pM, pP});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final Member pM, final Member pP, final Consumer super ParentTooYoung.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pM, pP}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM the fixed value of pattern parameter m, or null if not bound.
+ * @param pP the fixed value of pattern parameter p, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public ParentTooYoung.Match newMatch(final Member pM, final Member pP) {
+ return ParentTooYoung.Match.newMatch(pM, pP);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfm(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm() {
+ return rawStreamAllValuesOfm(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm(final ParentTooYoung.Match partialMatch) {
+ return rawStreamAllValuesOfm(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm(final Member pP) {
+ return rawStreamAllValuesOfm(new Object[]{null, pP});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm(final ParentTooYoung.Match partialMatch) {
+ return rawStreamAllValuesOfm(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm(final Member pP) {
+ return rawStreamAllValuesOfm(new Object[]{null, pP}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfp(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_P, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfp() {
+ return rawStreamAllValuesOfp(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfp() {
+ return rawStreamAllValuesOfp(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfp(final ParentTooYoung.Match partialMatch) {
+ return rawStreamAllValuesOfp(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfp(final Member pM) {
+ return rawStreamAllValuesOfp(new Object[]{pM, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfp(final ParentTooYoung.Match partialMatch) {
+ return rawStreamAllValuesOfp(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for p.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfp(final Member pM) {
+ return rawStreamAllValuesOfp(new Object[]{pM, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected ParentTooYoung.Match tupleToMatch(final Tuple t) {
+ try {
+ return ParentTooYoung.Match.newMatch((Member) t.get(POSITION_M), (Member) t.get(POSITION_P));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected ParentTooYoung.Match arrayToMatch(final Object[] match) {
+ try {
+ return ParentTooYoung.Match.newMatch((Member) match[POSITION_M], (Member) match[POSITION_P]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected ParentTooYoung.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return ParentTooYoung.Match.newMutableMatch((Member) match[POSITION_M], (Member) match[POSITION_P]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return ParentTooYoung.instance();
+ }
+ }
+
+ private ParentTooYoung() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static ParentTooYoung instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected ParentTooYoung.Matcher instantiate(final ViatraQueryEngine engine) {
+ return ParentTooYoung.Matcher.on(engine);
+ }
+
+ @Override
+ public ParentTooYoung.Matcher instantiate() {
+ return ParentTooYoung.Matcher.create();
+ }
+
+ @Override
+ public ParentTooYoung.Match newEmptyMatch() {
+ return ParentTooYoung.Match.newEmptyMatch();
+ }
+
+ @Override
+ public ParentTooYoung.Match newMatch(final Object... parameters) {
+ return ParentTooYoung.Match.newMatch((familytree.Member) parameters[0], (familytree.Member) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link ParentTooYoung} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link ParentTooYoung#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final ParentTooYoung INSTANCE = new ParentTooYoung();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final ParentTooYoung.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_p = new PParameter("p", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_m, parameter_p);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "queries.parentTooYoung";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("m","p");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_m = body.getOrCreateVariableByName("m");
+ PVariable var_p = body.getOrCreateVariableByName("p");
+ PVariable var___0_ = body.getOrCreateVariableByName("_<0>");
+ PVariable var_mAge = body.getOrCreateVariableByName("mAge");
+ PVariable var_pAge = body.getOrCreateVariableByName("pAge");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_m, parameter_m),
+ new ExportedParameter(body, var_p, parameter_p)
+ ));
+ // FamilyTree.members(_, m)
+ new TypeConstraint(body, Tuples.flatTupleOf(var___0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "FamilyTree")));
+ PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var___0_, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "FamilyTree", "members")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new Equality(body, var__virtual_0_, var_m);
+ // Member.parents(m, p)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new Equality(body, var__virtual_1_, var_p);
+ // Member.age(m, mAge)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+ new Equality(body, var__virtual_2_, var_mAge);
+ // Member.age(p, pAge)
+ new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_p, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt")));
+ new Equality(body, var__virtual_3_, var_pAge);
+ // check (mAge <= (pAge + 12))
+ new ExpressionEvaluation(body, new IExpressionEvaluator() {
+
+ @Override
+ public String getShortDescription() {
+ return "Expression evaluation from pattern parentTooYoung";
+ }
+
+ @Override
+ public Iterable getInputParameterNames() {
+ return Arrays.asList("mAge", "pAge");}
+
+ @Override
+ public Object evaluateExpression(IValueProvider provider) throws Exception {
+ Integer mAge = (Integer) provider.getValue("mAge");
+ Integer pAge = (Integer) provider.getValue("pAge");
+ return evaluateExpression_1_1(mAge, pAge);
+ }
+ }, null);
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("message", "parentTooYoung");
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("m"),
+ new ParameterReference("p")
+ }));
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+
+ private static boolean evaluateExpression_1_1(final Integer mAge, final Integer pAge) {
+ return ((mAge).intValue() <= ((pAge).intValue() + 12));
+ }
+}
diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java
index 58ad57a6..365939dd 100644
--- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java
+++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java
@@ -1,723 +1,723 @@
-/**
- * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
- */
-package queries;
-
-import familytree.Member;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.LinkedHashSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.function.Consumer;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-import org.apache.log4j.Logger;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.viatra.query.runtime.api.IPatternMatch;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
-import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
-import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
-import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
-import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
-import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
-import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
-import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
-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.PVisibility;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
-import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
-import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
-import queries.MemberHasParent;
-
-/**
- * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
- *
- *
- *
- * @see Matcher
- * @see Match
- *
- */
-@SuppressWarnings("all")
-public final class TwoMembersHaveNoParent extends BaseGeneratedEMFQuerySpecification {
- /**
- * Pattern-specific match representation of the queries.twoMembersHaveNoParent pattern,
- * to be used in conjunction with {@link Matcher}.
- *
- *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
- * Each instance is a (possibly partial) substitution of pattern parameters,
- * usable to represent a match of the pattern in the result of a query,
- * or to specify the bound (fixed) input parameters when issuing a query.
- *
- * @see Matcher
- *
- */
- public static abstract class Match extends BasePatternMatch {
- private Member fM1;
-
- private Member fM2;
-
- private static List parameterNames = makeImmutableList("m1", "m2");
-
- private Match(final Member pM1, final Member pM2) {
- this.fM1 = pM1;
- this.fM2 = pM2;
- }
-
- @Override
- public Object get(final String parameterName) {
- switch(parameterName) {
- case "m1": return this.fM1;
- case "m2": return this.fM2;
- default: return null;
- }
- }
-
- @Override
- public Object get(final int index) {
- switch(index) {
- case 0: return this.fM1;
- case 1: return this.fM2;
- default: return null;
- }
- }
-
- public Member getM1() {
- return this.fM1;
- }
-
- public Member getM2() {
- return this.fM2;
- }
-
- @Override
- public boolean set(final String parameterName, final Object newValue) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- if ("m1".equals(parameterName) ) {
- this.fM1 = (Member) newValue;
- return true;
- }
- if ("m2".equals(parameterName) ) {
- this.fM2 = (Member) newValue;
- return true;
- }
- return false;
- }
-
- public void setM1(final Member pM1) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fM1 = pM1;
- }
-
- public void setM2(final Member pM2) {
- if (!isMutable()) throw new java.lang.UnsupportedOperationException();
- this.fM2 = pM2;
- }
-
- @Override
- public String patternName() {
- return "queries.twoMembersHaveNoParent";
- }
-
- @Override
- public List parameterNames() {
- return TwoMembersHaveNoParent.Match.parameterNames;
- }
-
- @Override
- public Object[] toArray() {
- return new Object[]{fM1, fM2};
- }
-
- @Override
- public TwoMembersHaveNoParent.Match toImmutable() {
- return isMutable() ? newMatch(fM1, fM2) : this;
- }
-
- @Override
- public String prettyPrint() {
- StringBuilder result = new StringBuilder();
- result.append("\"m1\"=" + prettyPrintValue(fM1) + ", ");
- result.append("\"m2\"=" + prettyPrintValue(fM2));
- return result.toString();
- }
-
- @Override
- public int hashCode() {
- return Objects.hash(fM1, fM2);
- }
-
- @Override
- public boolean equals(final Object obj) {
- if (this == obj)
- return true;
- if (obj == null) {
- return false;
- }
- if ((obj instanceof TwoMembersHaveNoParent.Match)) {
- TwoMembersHaveNoParent.Match other = (TwoMembersHaveNoParent.Match) obj;
- return Objects.equals(fM1, other.fM1) && Objects.equals(fM2, other.fM2);
- } else {
- // this should be infrequent
- if (!(obj instanceof IPatternMatch)) {
- return false;
- }
- IPatternMatch otherSig = (IPatternMatch) obj;
- return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
- }
- }
-
- @Override
- public TwoMembersHaveNoParent specification() {
- return TwoMembersHaveNoParent.instance();
- }
-
- /**
- * Returns an empty, mutable match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @return the empty match.
- *
- */
- public static TwoMembersHaveNoParent.Match newEmptyMatch() {
- return new Mutable(null, null);
- }
-
- /**
- * Returns a mutable (partial) match.
- * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
- *
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return the new, mutable (partial) match object.
- *
- */
- public static TwoMembersHaveNoParent.Match newMutableMatch(final Member pM1, final Member pM2) {
- return new Mutable(pM1, pM2);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public static TwoMembersHaveNoParent.Match newMatch(final Member pM1, final Member pM2) {
- return new Immutable(pM1, pM2);
- }
-
- private static final class Mutable extends TwoMembersHaveNoParent.Match {
- Mutable(final Member pM1, final Member pM2) {
- super(pM1, pM2);
- }
-
- @Override
- public boolean isMutable() {
- return true;
- }
- }
-
- private static final class Immutable extends TwoMembersHaveNoParent.Match {
- Immutable(final Member pM1, final Member pM2) {
- super(pM1, pM2);
- }
-
- @Override
- public boolean isMutable() {
- return false;
- }
- }
- }
-
- /**
- * Generated pattern matcher API of the queries.twoMembersHaveNoParent pattern,
- * providing pattern-specific query methods.
- *
- *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
- * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
- *
- *
Matches of the pattern will be represented as {@link Match}.
- *
- *
- *
- * @see Match
- * @see TwoMembersHaveNoParent
- *
- */
- public static class Matcher extends BaseMatcher {
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- public static TwoMembersHaveNoParent.Matcher on(final ViatraQueryEngine engine) {
- // check if matcher already exists
- Matcher matcher = engine.getExistingMatcher(querySpecification());
- if (matcher == null) {
- matcher = (Matcher)engine.getMatcher(querySpecification());
- }
- return matcher;
- }
-
- /**
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- * @return an initialized matcher
- * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
- *
- */
- public static TwoMembersHaveNoParent.Matcher create() {
- return new Matcher();
- }
-
- private static final int POSITION_M1 = 0;
-
- private static final int POSITION_M2 = 1;
-
- private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(TwoMembersHaveNoParent.Matcher.class);
-
- /**
- * Initializes the pattern matcher within an existing VIATRA Query engine.
- * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
- *
- * @param engine the existing VIATRA Query engine in which this matcher will be created.
- * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
- *
- */
- private Matcher() {
- super(querySpecification());
- }
-
- /**
- * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return matches represented as a Match object.
- *
- */
- public Collection getAllMatches(final Member pM1, final Member pM2) {
- return rawStreamAllMatches(new Object[]{pM1, pM2}).collect(Collectors.toSet());
- }
-
- /**
- * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return a stream of matches represented as a Match object.
- *
- */
- public Stream streamAllMatches(final Member pM1, final Member pM2) {
- return rawStreamAllMatches(new Object[]{pM1, pM2});
- }
-
- /**
- * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return a match represented as a Match object, or null if no match is found.
- *
- */
- public Optional getOneArbitraryMatch(final Member pM1, final Member pM2) {
- return rawGetOneArbitraryMatch(new Object[]{pM1, pM2});
- }
-
- /**
- * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
- * under any possible substitution of the unspecified parameters (if any).
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return true if the input is a valid (partial) match of the pattern.
- *
- */
- public boolean hasMatch(final Member pM1, final Member pM2) {
- return rawHasMatch(new Object[]{pM1, pM2});
- }
-
- /**
- * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return the number of pattern matches found.
- *
- */
- public int countMatches(final Member pM1, final Member pM2) {
- return rawCountMatches(new Object[]{pM1, pM2});
- }
-
- /**
- * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
- * Neither determinism nor randomness of selection is guaranteed.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @param processor the action that will process the selected match.
- * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
- *
- */
- public boolean forOneArbitraryMatch(final Member pM1, final Member pM2, final Consumer super TwoMembersHaveNoParent.Match> processor) {
- return rawForOneArbitraryMatch(new Object[]{pM1, pM2}, processor);
- }
-
- /**
- * Returns a new (partial) match.
- * This can be used e.g. to call the matcher with a partial match.
- *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
- * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
- * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
- * @return the (partial) match object.
- *
- */
- public TwoMembersHaveNoParent.Match newMatch(final Member pM1, final Member pM2) {
- return TwoMembersHaveNoParent.Match.newMatch(pM1, pM2);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfm1(final Object[] parameters) {
- return rawStreamAllValues(POSITION_M1, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm1() {
- return rawStreamAllValuesOfm1(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm1() {
- return rawStreamAllValuesOfm1(emptyArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm1(final TwoMembersHaveNoParent.Match partialMatch) {
- return rawStreamAllValuesOfm1(partialMatch.toArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm1(final Member pM2) {
- return rawStreamAllValuesOfm1(new Object[]{null, pM2});
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm1(final TwoMembersHaveNoParent.Match partialMatch) {
- return rawStreamAllValuesOfm1(partialMatch.toArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m1.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm1(final Member pM2) {
- return rawStreamAllValuesOfm1(new Object[]{null, pM2}).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- protected Stream rawStreamAllValuesOfm2(final Object[] parameters) {
- return rawStreamAllValues(POSITION_M2, parameters).map(Member.class::cast);
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm2() {
- return rawStreamAllValuesOfm2(emptyArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm2() {
- return rawStreamAllValuesOfm2(emptyArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm2(final TwoMembersHaveNoParent.Match partialMatch) {
- return rawStreamAllValuesOfm2(partialMatch.toArray());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- *
- * NOTE: It is important not to modify the source model while the stream is being processed.
- * If the match set of the pattern changes during processing, the contents of the stream is undefined.
- * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
- *
- * @return the Stream of all values or empty set if there are no matches
- *
- */
- public Stream streamAllValuesOfm2(final Member pM1) {
- return rawStreamAllValuesOfm2(new Object[]{pM1, null});
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm2(final TwoMembersHaveNoParent.Match partialMatch) {
- return rawStreamAllValuesOfm2(partialMatch.toArray()).collect(Collectors.toSet());
- }
-
- /**
- * Retrieve the set of values that occur in matches for m2.
- * @return the Set of all values or empty set if there are no matches
- *
- */
- public Set getAllValuesOfm2(final Member pM1) {
- return rawStreamAllValuesOfm2(new Object[]{pM1, null}).collect(Collectors.toSet());
- }
-
- @Override
- protected TwoMembersHaveNoParent.Match tupleToMatch(final Tuple t) {
- try {
- return TwoMembersHaveNoParent.Match.newMatch((Member) t.get(POSITION_M1), (Member) t.get(POSITION_M2));
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in tuple not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected TwoMembersHaveNoParent.Match arrayToMatch(final Object[] match) {
- try {
- return TwoMembersHaveNoParent.Match.newMatch((Member) match[POSITION_M1], (Member) match[POSITION_M2]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- @Override
- protected TwoMembersHaveNoParent.Match arrayToMatchMutable(final Object[] match) {
- try {
- return TwoMembersHaveNoParent.Match.newMutableMatch((Member) match[POSITION_M1], (Member) match[POSITION_M2]);
- } catch(ClassCastException e) {
- LOGGER.error("Element(s) in array not properly typed!",e);
- return null;
- }
- }
-
- /**
- * @return the singleton instance of the query specification of this pattern
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static IQuerySpecification querySpecification() {
- return TwoMembersHaveNoParent.instance();
- }
- }
-
- private TwoMembersHaveNoParent() {
- super(GeneratedPQuery.INSTANCE);
- }
-
- /**
- * @return the singleton instance of the query specification
- * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
- *
- */
- public static TwoMembersHaveNoParent instance() {
- try{
- return LazyHolder.INSTANCE;
- } catch (ExceptionInInitializerError err) {
- throw processInitializerError(err);
- }
- }
-
- @Override
- protected TwoMembersHaveNoParent.Matcher instantiate(final ViatraQueryEngine engine) {
- return TwoMembersHaveNoParent.Matcher.on(engine);
- }
-
- @Override
- public TwoMembersHaveNoParent.Matcher instantiate() {
- return TwoMembersHaveNoParent.Matcher.create();
- }
-
- @Override
- public TwoMembersHaveNoParent.Match newEmptyMatch() {
- return TwoMembersHaveNoParent.Match.newEmptyMatch();
- }
-
- @Override
- public TwoMembersHaveNoParent.Match newMatch(final Object... parameters) {
- return TwoMembersHaveNoParent.Match.newMatch((familytree.Member) parameters[0], (familytree.Member) parameters[1]);
- }
-
- /**
- * Inner class allowing the singleton instance of {@link TwoMembersHaveNoParent} to be created
- * not at the class load time of the outer class,
- * but rather at the first call to {@link TwoMembersHaveNoParent#instance()}.
- *
- *
This workaround is required e.g. to support recursion.
- *
- */
- private static class LazyHolder {
- private static final TwoMembersHaveNoParent INSTANCE = new TwoMembersHaveNoParent();
-
- /**
- * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
- * This initialization order is required to support indirect recursion.
- *
- *
The static initializer is defined using a helper field to work around limitations of the code generator.
- *
- */
- private static final Object STATIC_INITIALIZER = ensureInitialized();
-
- public static Object ensureInitialized() {
- INSTANCE.ensureInitializedInternal();
- return null;
- }
- }
-
- private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
- private static final TwoMembersHaveNoParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
-
- private final PParameter parameter_m1 = new PParameter("m1", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final PParameter parameter_m2 = new PParameter("m2", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
-
- private final List parameters = Arrays.asList(parameter_m1, parameter_m2);
-
- private GeneratedPQuery() {
- super(PVisibility.PUBLIC);
- }
-
- @Override
- public String getFullyQualifiedName() {
- return "queries.twoMembersHaveNoParent";
- }
-
- @Override
- public List getParameterNames() {
- return Arrays.asList("m1","m2");
- }
-
- @Override
- public List getParameters() {
- return parameters;
- }
-
- @Override
- public Set doGetContainedBodies() {
- setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
- Set bodies = new LinkedHashSet<>();
- {
- PBody body = new PBody(this);
- PVariable var_m1 = body.getOrCreateVariableByName("m1");
- PVariable var_m2 = body.getOrCreateVariableByName("m2");
- new TypeConstraint(body, Tuples.flatTupleOf(var_m1), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- new TypeConstraint(body, Tuples.flatTupleOf(var_m2), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
- body.setSymbolicParameters(Arrays.asList(
- new ExportedParameter(body, var_m1, parameter_m1),
- new ExportedParameter(body, var_m2, parameter_m2)
- ));
- // neg find memberHasParent(m1)
- new NegativePatternCall(body, Tuples.flatTupleOf(var_m1), MemberHasParent.instance().getInternalQueryRepresentation());
- // neg find memberHasParent(m2)
- new NegativePatternCall(body, Tuples.flatTupleOf(var_m2), MemberHasParent.instance().getInternalQueryRepresentation());
- // m1 != m2
- new Inequality(body, var_m1, var_m2);
- bodies.add(body);
- }
- {
- PAnnotation annotation = new PAnnotation("Constraint");
- annotation.addAttribute("message", "twoMembersHaveNoParent");
- annotation.addAttribute("severity", "error");
- annotation.addAttribute("key", Arrays.asList(new Object[] {
- new ParameterReference("m1"),
- new ParameterReference("m2")
- }));
- addAnnotation(annotation);
- }
- return bodies;
- }
- }
-}
+/**
+ * Generated from platform:/resource/case.study.familyTree.run/src/queries/familyTreeConstraints.vql
+ */
+package queries;
+
+import familytree.Member;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.apache.log4j.Logger;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.viatra.query.runtime.api.IPatternMatch;
+import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFPQuery;
+import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedEMFQuerySpecification;
+import org.eclipse.viatra.query.runtime.api.impl.BaseMatcher;
+import org.eclipse.viatra.query.runtime.api.impl.BasePatternMatch;
+import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey;
+import org.eclipse.viatra.query.runtime.matchers.backend.QueryEvaluationHint;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PBody;
+import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
+import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.ParameterReference;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall;
+import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint;
+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.PVisibility;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuple;
+import org.eclipse.viatra.query.runtime.matchers.tuple.Tuples;
+import org.eclipse.viatra.query.runtime.util.ViatraQueryLoggingUtil;
+import queries.MemberHasParent;
+
+/**
+ * A pattern-specific query specification that can instantiate Matcher in a type-safe way.
+ *
+ *
+ *
+ * @see Matcher
+ * @see Match
+ *
+ */
+@SuppressWarnings("all")
+public final class TwoMembersHaveNoParent extends BaseGeneratedEMFQuerySpecification {
+ /**
+ * Pattern-specific match representation of the queries.twoMembersHaveNoParent pattern,
+ * to be used in conjunction with {@link Matcher}.
+ *
+ *
Class fields correspond to parameters of the pattern. Fields with value null are considered unassigned.
+ * Each instance is a (possibly partial) substitution of pattern parameters,
+ * usable to represent a match of the pattern in the result of a query,
+ * or to specify the bound (fixed) input parameters when issuing a query.
+ *
+ * @see Matcher
+ *
+ */
+ public static abstract class Match extends BasePatternMatch {
+ private Member fM1;
+
+ private Member fM2;
+
+ private static List parameterNames = makeImmutableList("m1", "m2");
+
+ private Match(final Member pM1, final Member pM2) {
+ this.fM1 = pM1;
+ this.fM2 = pM2;
+ }
+
+ @Override
+ public Object get(final String parameterName) {
+ switch(parameterName) {
+ case "m1": return this.fM1;
+ case "m2": return this.fM2;
+ default: return null;
+ }
+ }
+
+ @Override
+ public Object get(final int index) {
+ switch(index) {
+ case 0: return this.fM1;
+ case 1: return this.fM2;
+ default: return null;
+ }
+ }
+
+ public Member getM1() {
+ return this.fM1;
+ }
+
+ public Member getM2() {
+ return this.fM2;
+ }
+
+ @Override
+ public boolean set(final String parameterName, final Object newValue) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ if ("m1".equals(parameterName) ) {
+ this.fM1 = (Member) newValue;
+ return true;
+ }
+ if ("m2".equals(parameterName) ) {
+ this.fM2 = (Member) newValue;
+ return true;
+ }
+ return false;
+ }
+
+ public void setM1(final Member pM1) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fM1 = pM1;
+ }
+
+ public void setM2(final Member pM2) {
+ if (!isMutable()) throw new java.lang.UnsupportedOperationException();
+ this.fM2 = pM2;
+ }
+
+ @Override
+ public String patternName() {
+ return "queries.twoMembersHaveNoParent";
+ }
+
+ @Override
+ public List parameterNames() {
+ return TwoMembersHaveNoParent.Match.parameterNames;
+ }
+
+ @Override
+ public Object[] toArray() {
+ return new Object[]{fM1, fM2};
+ }
+
+ @Override
+ public TwoMembersHaveNoParent.Match toImmutable() {
+ return isMutable() ? newMatch(fM1, fM2) : this;
+ }
+
+ @Override
+ public String prettyPrint() {
+ StringBuilder result = new StringBuilder();
+ result.append("\"m1\"=" + prettyPrintValue(fM1) + ", ");
+ result.append("\"m2\"=" + prettyPrintValue(fM2));
+ return result.toString();
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(fM1, fM2);
+ }
+
+ @Override
+ public boolean equals(final Object obj) {
+ if (this == obj)
+ return true;
+ if (obj == null) {
+ return false;
+ }
+ if ((obj instanceof TwoMembersHaveNoParent.Match)) {
+ TwoMembersHaveNoParent.Match other = (TwoMembersHaveNoParent.Match) obj;
+ return Objects.equals(fM1, other.fM1) && Objects.equals(fM2, other.fM2);
+ } else {
+ // this should be infrequent
+ if (!(obj instanceof IPatternMatch)) {
+ return false;
+ }
+ IPatternMatch otherSig = (IPatternMatch) obj;
+ return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray());
+ }
+ }
+
+ @Override
+ public TwoMembersHaveNoParent specification() {
+ return TwoMembersHaveNoParent.instance();
+ }
+
+ /**
+ * Returns an empty, mutable match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @return the empty match.
+ *
+ */
+ public static TwoMembersHaveNoParent.Match newEmptyMatch() {
+ return new Mutable(null, null);
+ }
+
+ /**
+ * Returns a mutable (partial) match.
+ * Fields of the mutable match can be filled to create a partial match, usable as matcher input.
+ *
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return the new, mutable (partial) match object.
+ *
+ */
+ public static TwoMembersHaveNoParent.Match newMutableMatch(final Member pM1, final Member pM2) {
+ return new Mutable(pM1, pM2);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public static TwoMembersHaveNoParent.Match newMatch(final Member pM1, final Member pM2) {
+ return new Immutable(pM1, pM2);
+ }
+
+ private static final class Mutable extends TwoMembersHaveNoParent.Match {
+ Mutable(final Member pM1, final Member pM2) {
+ super(pM1, pM2);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return true;
+ }
+ }
+
+ private static final class Immutable extends TwoMembersHaveNoParent.Match {
+ Immutable(final Member pM1, final Member pM2) {
+ super(pM1, pM2);
+ }
+
+ @Override
+ public boolean isMutable() {
+ return false;
+ }
+ }
+ }
+
+ /**
+ * Generated pattern matcher API of the queries.twoMembersHaveNoParent pattern,
+ * providing pattern-specific query methods.
+ *
+ *
Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)},
+ * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}.
+ *
+ *
Matches of the pattern will be represented as {@link Match}.
+ *
+ *
+ *
+ * @see Match
+ * @see TwoMembersHaveNoParent
+ *
+ */
+ public static class Matcher extends BaseMatcher {
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ public static TwoMembersHaveNoParent.Matcher on(final ViatraQueryEngine engine) {
+ // check if matcher already exists
+ Matcher matcher = engine.getExistingMatcher(querySpecification());
+ if (matcher == null) {
+ matcher = (Matcher)engine.getMatcher(querySpecification());
+ }
+ return matcher;
+ }
+
+ /**
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ * @return an initialized matcher
+ * @noreference This method is for internal matcher initialization by the framework, do not call it manually.
+ *
+ */
+ public static TwoMembersHaveNoParent.Matcher create() {
+ return new Matcher();
+ }
+
+ private static final int POSITION_M1 = 0;
+
+ private static final int POSITION_M2 = 1;
+
+ private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(TwoMembersHaveNoParent.Matcher.class);
+
+ /**
+ * Initializes the pattern matcher within an existing VIATRA Query engine.
+ * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned.
+ *
+ * @param engine the existing VIATRA Query engine in which this matcher will be created.
+ * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation
+ *
+ */
+ private Matcher() {
+ super(querySpecification());
+ }
+
+ /**
+ * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return matches represented as a Match object.
+ *
+ */
+ public Collection getAllMatches(final Member pM1, final Member pM2) {
+ return rawStreamAllMatches(new Object[]{pM1, pM2}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return a stream of matches represented as a Match object.
+ *
+ */
+ public Stream streamAllMatches(final Member pM1, final Member pM2) {
+ return rawStreamAllMatches(new Object[]{pM1, pM2});
+ }
+
+ /**
+ * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return a match represented as a Match object, or null if no match is found.
+ *
+ */
+ public Optional getOneArbitraryMatch(final Member pM1, final Member pM2) {
+ return rawGetOneArbitraryMatch(new Object[]{pM1, pM2});
+ }
+
+ /**
+ * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match,
+ * under any possible substitution of the unspecified parameters (if any).
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return true if the input is a valid (partial) match of the pattern.
+ *
+ */
+ public boolean hasMatch(final Member pM1, final Member pM2) {
+ return rawHasMatch(new Object[]{pM1, pM2});
+ }
+
+ /**
+ * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return the number of pattern matches found.
+ *
+ */
+ public int countMatches(final Member pM1, final Member pM2) {
+ return rawCountMatches(new Object[]{pM1, pM2});
+ }
+
+ /**
+ * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters.
+ * Neither determinism nor randomness of selection is guaranteed.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @param processor the action that will process the selected match.
+ * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked
+ *
+ */
+ public boolean forOneArbitraryMatch(final Member pM1, final Member pM2, final Consumer super TwoMembersHaveNoParent.Match> processor) {
+ return rawForOneArbitraryMatch(new Object[]{pM1, pM2}, processor);
+ }
+
+ /**
+ * Returns a new (partial) match.
+ * This can be used e.g. to call the matcher with a partial match.
+ *
The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object.
+ * @param pM1 the fixed value of pattern parameter m1, or null if not bound.
+ * @param pM2 the fixed value of pattern parameter m2, or null if not bound.
+ * @return the (partial) match object.
+ *
+ */
+ public TwoMembersHaveNoParent.Match newMatch(final Member pM1, final Member pM2) {
+ return TwoMembersHaveNoParent.Match.newMatch(pM1, pM2);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfm1(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_M1, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm1() {
+ return rawStreamAllValuesOfm1(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm1() {
+ return rawStreamAllValuesOfm1(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm1(final TwoMembersHaveNoParent.Match partialMatch) {
+ return rawStreamAllValuesOfm1(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm1(final Member pM2) {
+ return rawStreamAllValuesOfm1(new Object[]{null, pM2});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm1(final TwoMembersHaveNoParent.Match partialMatch) {
+ return rawStreamAllValuesOfm1(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m1.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm1(final Member pM2) {
+ return rawStreamAllValuesOfm1(new Object[]{null, pM2}).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ protected Stream rawStreamAllValuesOfm2(final Object[] parameters) {
+ return rawStreamAllValues(POSITION_M2, parameters).map(Member.class::cast);
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm2() {
+ return rawStreamAllValuesOfm2(emptyArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm2() {
+ return rawStreamAllValuesOfm2(emptyArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm2(final TwoMembersHaveNoParent.Match partialMatch) {
+ return rawStreamAllValuesOfm2(partialMatch.toArray());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ *
+ * NOTE: It is important not to modify the source model while the stream is being processed.
+ * If the match set of the pattern changes during processing, the contents of the stream is undefined.
+ * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code.
+ *
+ * @return the Stream of all values or empty set if there are no matches
+ *
+ */
+ public Stream streamAllValuesOfm2(final Member pM1) {
+ return rawStreamAllValuesOfm2(new Object[]{pM1, null});
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm2(final TwoMembersHaveNoParent.Match partialMatch) {
+ return rawStreamAllValuesOfm2(partialMatch.toArray()).collect(Collectors.toSet());
+ }
+
+ /**
+ * Retrieve the set of values that occur in matches for m2.
+ * @return the Set of all values or empty set if there are no matches
+ *
+ */
+ public Set getAllValuesOfm2(final Member pM1) {
+ return rawStreamAllValuesOfm2(new Object[]{pM1, null}).collect(Collectors.toSet());
+ }
+
+ @Override
+ protected TwoMembersHaveNoParent.Match tupleToMatch(final Tuple t) {
+ try {
+ return TwoMembersHaveNoParent.Match.newMatch((Member) t.get(POSITION_M1), (Member) t.get(POSITION_M2));
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in tuple not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected TwoMembersHaveNoParent.Match arrayToMatch(final Object[] match) {
+ try {
+ return TwoMembersHaveNoParent.Match.newMatch((Member) match[POSITION_M1], (Member) match[POSITION_M2]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ @Override
+ protected TwoMembersHaveNoParent.Match arrayToMatchMutable(final Object[] match) {
+ try {
+ return TwoMembersHaveNoParent.Match.newMutableMatch((Member) match[POSITION_M1], (Member) match[POSITION_M2]);
+ } catch(ClassCastException e) {
+ LOGGER.error("Element(s) in array not properly typed!",e);
+ return null;
+ }
+ }
+
+ /**
+ * @return the singleton instance of the query specification of this pattern
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static IQuerySpecification querySpecification() {
+ return TwoMembersHaveNoParent.instance();
+ }
+ }
+
+ private TwoMembersHaveNoParent() {
+ super(GeneratedPQuery.INSTANCE);
+ }
+
+ /**
+ * @return the singleton instance of the query specification
+ * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded
+ *
+ */
+ public static TwoMembersHaveNoParent instance() {
+ try{
+ return LazyHolder.INSTANCE;
+ } catch (ExceptionInInitializerError err) {
+ throw processInitializerError(err);
+ }
+ }
+
+ @Override
+ protected TwoMembersHaveNoParent.Matcher instantiate(final ViatraQueryEngine engine) {
+ return TwoMembersHaveNoParent.Matcher.on(engine);
+ }
+
+ @Override
+ public TwoMembersHaveNoParent.Matcher instantiate() {
+ return TwoMembersHaveNoParent.Matcher.create();
+ }
+
+ @Override
+ public TwoMembersHaveNoParent.Match newEmptyMatch() {
+ return TwoMembersHaveNoParent.Match.newEmptyMatch();
+ }
+
+ @Override
+ public TwoMembersHaveNoParent.Match newMatch(final Object... parameters) {
+ return TwoMembersHaveNoParent.Match.newMatch((familytree.Member) parameters[0], (familytree.Member) parameters[1]);
+ }
+
+ /**
+ * Inner class allowing the singleton instance of {@link TwoMembersHaveNoParent} to be created
+ * not at the class load time of the outer class,
+ * but rather at the first call to {@link TwoMembersHaveNoParent#instance()}.
+ *
+ *
This workaround is required e.g. to support recursion.
+ *
+ */
+ private static class LazyHolder {
+ private static final TwoMembersHaveNoParent INSTANCE = new TwoMembersHaveNoParent();
+
+ /**
+ * Statically initializes the query specification after the field {@link #INSTANCE} is assigned.
+ * This initialization order is required to support indirect recursion.
+ *
+ *
The static initializer is defined using a helper field to work around limitations of the code generator.
+ *
+ */
+ private static final Object STATIC_INITIALIZER = ensureInitialized();
+
+ public static Object ensureInitialized() {
+ INSTANCE.ensureInitializedInternal();
+ return null;
+ }
+ }
+
+ private static class GeneratedPQuery extends BaseGeneratedEMFPQuery {
+ private static final TwoMembersHaveNoParent.GeneratedPQuery INSTANCE = new GeneratedPQuery();
+
+ private final PParameter parameter_m1 = new PParameter("m1", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final PParameter parameter_m2 = new PParameter("m2", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT);
+
+ private final List parameters = Arrays.asList(parameter_m1, parameter_m2);
+
+ private GeneratedPQuery() {
+ super(PVisibility.PUBLIC);
+ }
+
+ @Override
+ public String getFullyQualifiedName() {
+ return "queries.twoMembersHaveNoParent";
+ }
+
+ @Override
+ public List getParameterNames() {
+ return Arrays.asList("m1","m2");
+ }
+
+ @Override
+ public List getParameters() {
+ return parameters;
+ }
+
+ @Override
+ public Set doGetContainedBodies() {
+ setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED));
+ Set bodies = new LinkedHashSet<>();
+ {
+ PBody body = new PBody(this);
+ PVariable var_m1 = body.getOrCreateVariableByName("m1");
+ PVariable var_m2 = body.getOrCreateVariableByName("m2");
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m1), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ new TypeConstraint(body, Tuples.flatTupleOf(var_m2), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member")));
+ body.setSymbolicParameters(Arrays.asList(
+ new ExportedParameter(body, var_m1, parameter_m1),
+ new ExportedParameter(body, var_m2, parameter_m2)
+ ));
+ // neg find memberHasParent(m1)
+ new NegativePatternCall(body, Tuples.flatTupleOf(var_m1), MemberHasParent.instance().getInternalQueryRepresentation());
+ // neg find memberHasParent(m2)
+ new NegativePatternCall(body, Tuples.flatTupleOf(var_m2), MemberHasParent.instance().getInternalQueryRepresentation());
+ // m1 != m2
+ new Inequality(body, var_m1, var_m2);
+ bodies.add(body);
+ }
+ {
+ PAnnotation annotation = new PAnnotation("Constraint");
+ annotation.addAttribute("message", "twoMembersHaveNoParent");
+ annotation.addAttribute("severity", "error");
+ annotation.addAttribute("key", Arrays.asList(new Object[] {
+ new ParameterReference("m1"),
+ new ParameterReference("m2")
+ }));
+ addAnnotation(annotation);
+ }
+ return bodies;
+ }
+ }
+}
diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml
index 63aa0b02..8b036ff2 100644
--- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml
+++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/plugin.xml
@@ -1,42 +1,42 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin
index 3430ce88..163f84a1 100644
Binary files a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin and b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/.GeneratePledgeModels.xtendbin differ
diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java
index 35ddb32f..2809679d 100644
--- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java
+++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/xtend-gen/run/GeneratePledgeModels.java
@@ -1,314 +1,314 @@
-package run;
-
-import Taxation.TaxationPackage;
-import com.google.common.base.Objects;
-import com.google.common.collect.Iterables;
-import com.google.inject.Injector;
-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic;
-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2LogicConfiguration;
-import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace;
-import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor;
-import hu.bme.mit.inf.dslreasoner.logic.model.builder.DocumentationLevel;
-import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicModelInterpretation;
-import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput;
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type;
-import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem;
-import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.LogicResult;
-import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.ModelResult;
-import hu.bme.mit.inf.dslreasoner.logic.model.logicresult.Statistics;
-import hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore;
-import hu.bme.mit.inf.dslreasoner.viatra2logic.Viatra2Logic;
-import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic.InstanceModel2Logic;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretation2Gml;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.visualisation.PartialInterpretationVisualisation;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.DebugConfiguration;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner;
-import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasonerConfiguration;
-import hu.bme.mit.inf.dslreasoner.visualisation.pi2graphviz.GraphvizVisualiser;
-import hu.bme.mit.inf.dslreasoner.workspace.FileSystemWorkspace;
-import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace;
-import java.math.BigDecimal;
-import java.text.SimpleDateFormat;
-import java.util.Collections;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import org.eclipse.emf.common.util.EList;
-import org.eclipse.emf.ecore.EAttribute;
-import org.eclipse.emf.ecore.EClass;
-import org.eclipse.emf.ecore.EEnum;
-import org.eclipse.emf.ecore.EEnumLiteral;
-import org.eclipse.emf.ecore.EObject;
-import org.eclipse.emf.ecore.EPackage;
-import org.eclipse.emf.ecore.EReference;
-import org.eclipse.emf.ecore.EStructuralFeature;
-import org.eclipse.emf.ecore.resource.Resource;
-import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
-import org.eclipse.viatra.query.patternlanguage.emf.EMFPatternLanguageStandaloneSetup;
-import org.eclipse.viatra.query.runtime.api.IQueryGroup;
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification;
-import org.eclipse.viatra.query.runtime.matchers.psystem.annotations.PAnnotation;
-import org.eclipse.viatra.query.runtime.rete.matcher.ReteEngine;
-import org.eclipse.xtend2.lib.StringConcatenation;
-import org.eclipse.xtext.xbase.lib.CollectionExtensions;
-import org.eclipse.xtext.xbase.lib.CollectionLiterals;
-import org.eclipse.xtext.xbase.lib.Exceptions;
-import org.eclipse.xtext.xbase.lib.ExclusiveRange;
-import org.eclipse.xtext.xbase.lib.Functions.Function1;
-import org.eclipse.xtext.xbase.lib.InputOutput;
-import org.eclipse.xtext.xbase.lib.IterableExtensions;
-import org.eclipse.xtext.xbase.lib.ListExtensions;
-import org.eclipse.xtext.xbase.lib.ObjectExtensions;
-import org.eclipse.xtext.xbase.lib.Procedures.Procedure1;
-
-@SuppressWarnings("all")
-public class GeneratePledgeModels {
- public static void main(final String[] args) {
- try {
- final Injector x = new EMFPatternLanguageStandaloneSetup().createInjectorAndDoEMFRegistration();
- Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
- XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
- _extensionToFactoryMap.put("xmi", _xMIResourceFactoryImpl);
- Map _extensionToFactoryMap_1 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
- XMIResourceFactoryImpl _xMIResourceFactoryImpl_1 = new XMIResourceFactoryImpl();
- _extensionToFactoryMap_1.put("logicproblem", _xMIResourceFactoryImpl_1);
- Map _extensionToFactoryMap_2 = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
- XMIResourceFactoryImpl _xMIResourceFactoryImpl_2 = new XMIResourceFactoryImpl();
- _extensionToFactoryMap_2.put("partialmodel", _xMIResourceFactoryImpl_2);
- ReteEngine.class.getClass();
- final Ecore2Logic ecore2Logic = new Ecore2Logic();
- final Logic2Ecore logic2Ecore = new Logic2Ecore(ecore2Logic);
- final Viatra2Logic viatra2Logic = new Viatra2Logic(ecore2Logic);
- final InstanceModel2Logic instanceModel2Logic = new InstanceModel2Logic();
- long _currentTimeMillis = System.currentTimeMillis();
- final Date date = new Date(_currentTimeMillis);
- final SimpleDateFormat format = new SimpleDateFormat("dd-HHmm");
- final String formattedDate = format.format(date);
- StringConcatenation _builder = new StringConcatenation();
- _builder.append("inputs/");
- final FileSystemWorkspace inputs = new FileSystemWorkspace(_builder.toString(), "");
- StringConcatenation _builder_1 = new StringConcatenation();
- _builder_1.append("output/");
- String _plus = (_builder_1.toString() + formattedDate);
- StringConcatenation _builder_2 = new StringConcatenation();
- _builder_2.append("/");
- String _plus_1 = (_plus + _builder_2);
- final FileSystemWorkspace workspace = new FileSystemWorkspace(_plus_1, "");
- StringConcatenation _builder_3 = new StringConcatenation();
- _builder_3.append("output/");
- String _plus_2 = (_builder_3.toString() + formattedDate);
- StringConcatenation _builder_4 = new StringConcatenation();
- _builder_4.append("/debug/");
- String _plus_3 = (_plus_2 + _builder_4);
- final FileSystemWorkspace debug = new FileSystemWorkspace(_plus_3, "");
- workspace.initAndClear();
- InputOutput.println("Input and output workspaces are created");
- final EcoreMetamodelDescriptor metamodel = GeneratePledgeModels.loadMetamodel(TaxationPackage.eINSTANCE);
- final EList partialModel = GeneratePledgeModels.loadPartialModel(inputs, "Household.xmi");
- InputOutput.println("DSL loaded");
- final int SIZE = 2;
- int REPS = 1;
- final int RUNTIME = 600;
- Ecore2LogicConfiguration _ecore2LogicConfiguration = new Ecore2LogicConfiguration();
- final TracedOutput modelGenerationProblem = ecore2Logic.transformMetamodel(metamodel, _ecore2LogicConfiguration);
- LogicProblem problem = modelGenerationProblem.getOutput();
- debug.writeModel(problem, "problem.logicproblem");
- InputOutput.println("Problem created");
- for (int i = 0; (i < REPS); i++) {
- {
- ViatraReasoner reasoner = new ViatraReasoner();
- final TreeSet knownIntegers = new TreeSet();
- CollectionExtensions.addAll(knownIntegers, Integer.valueOf(0));
- final TreeSet knownReals = new TreeSet();
- BigDecimal _bigDecimal = new BigDecimal("0.0");
- CollectionExtensions.addAll(knownReals, _bigDecimal);
- final TreeSet knownStrings = new TreeSet();
- CollectionExtensions.addAll(knownStrings, "r0", "r1", "r2");
- ViatraReasonerConfiguration _viatraReasonerConfiguration = new ViatraReasonerConfiguration();
- final Procedure1 _function = (ViatraReasonerConfiguration it) -> {
- it.documentationLevel = DocumentationLevel.FULL;
- DebugConfiguration _debugConfiguration = new DebugConfiguration();
- final Procedure1 _function_1 = (DebugConfiguration it_1) -> {
- it_1.logging = true;
- };
- DebugConfiguration _doubleArrow = ObjectExtensions.operator_doubleArrow(_debugConfiguration, _function_1);
- it.debugCongiguration = _doubleArrow;
- it.runtimeLimit = RUNTIME;
- boolean _isEmpty = knownIntegers.isEmpty();
- boolean _not = (!_isEmpty);
- if (_not) {
- it.typeScopes.knownIntegers = knownIntegers;
- }
- boolean _isEmpty_1 = knownReals.isEmpty();
- boolean _not_1 = (!_isEmpty_1);
- if (_not_1) {
- it.typeScopes.knownReals = knownReals;
- }
- };
- final ViatraReasonerConfiguration solverConfig = ObjectExtensions.operator_doubleArrow(_viatraReasonerConfiguration, _function);
- InputOutput.println((("Run #" + Integer.valueOf(i)) + ":"));
- final long startTime = System.currentTimeMillis();
- LogicResult solution = reasoner.solve(problem, solverConfig, debug);
- long _currentTimeMillis_1 = System.currentTimeMillis();
- final long totalTime = (_currentTimeMillis_1 - startTime);
- InputOutput.println(" Problem Solved");
- GeneratePledgeModels.writeStats(solution, totalTime, solverConfig);
- if ((solution instanceof ModelResult)) {
- GeneratePledgeModels.writeRepresentation(solution, workspace, i);
- GeneratePledgeModels.writeInterpretation(solution, logic2Ecore, workspace, i, reasoner, modelGenerationProblem);
- InputOutput.println(" Solution saved and visualised");
- } else {
- String _string = solution.getClass().getSimpleName().toString();
- String _plus_4 = (" Returned: " + _string);
- InputOutput.println(_plus_4);
- }
- final Runtime r = Runtime.getRuntime();
- r.gc();
- r.gc();
- r.gc();
- Thread.sleep(3000);
- }
- }
- InputOutput.println("---End---");
- } catch (Throwable _e) {
- throw Exceptions.sneakyThrow(_e);
- }
- }
-
- public static Map getTypeMap(final Map classMap, final EcoreMetamodelDescriptor metamodel, final Ecore2Logic e2l, final Ecore2Logic_Trace trace) {
- final HashMap typeMap = new HashMap();
- final Function1 _function = (EClass s) -> {
- return s.getName();
- };
- final Map listMap = IterableExtensions.toMap(metamodel.getClasses(), _function);
- Set _keySet = classMap.keySet();
- for (final Class elem : _keySet) {
- typeMap.put(
- e2l.TypeofEClass(trace,
- listMap.get(elem.getSimpleName())), classMap.get(elem));
- }
- return typeMap;
- }
-
- public static EcoreMetamodelDescriptor loadMetamodel(final EPackage pckg) {
- final List classes = IterableExtensions.toList(Iterables.filter(pckg.getEClassifiers(), EClass.class));
- final List enums = IterableExtensions.toList(Iterables.filter(pckg.getEClassifiers(), EEnum.class));
- final Function1> _function = (EEnum it) -> {
- return it.getELiterals();
- };
- final List literals = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(enums, _function)));
- final Function1> _function_1 = (EClass it) -> {
- return it.getEReferences();
- };
- final List references = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(classes, _function_1)));
- final Function1> _function_2 = (EClass it) -> {
- return it.getEAttributes();
- };
- final List attributes = IterableExtensions.toList(Iterables.concat(ListExtensions.>map(classes, _function_2)));
- return new EcoreMetamodelDescriptor(classes, Collections.unmodifiableSet(CollectionLiterals.newHashSet()), false, enums, literals, references, attributes);
- }
-
- public static EList loadPartialModel(final ReasonerWorkspace inputs, final String path) {
- EList _xblockexpression = null;
- {
- Map _extensionToFactoryMap = Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap();
- XMIResourceFactoryImpl _xMIResourceFactoryImpl = new XMIResourceFactoryImpl();
- _extensionToFactoryMap.put("*", _xMIResourceFactoryImpl);
- _xblockexpression = inputs.readModel(EObject.class, path).eResource().getContents();
- }
- return _xblockexpression;
- }
-
- public static ViatraQuerySetDescriptor loadQueries(final EcoreMetamodelDescriptor metamodel, final IQueryGroup i) {
- final List> patterns = IterableExtensions.>toList(i.getSpecifications());
- final Function1, Boolean> _function = (IQuerySpecification> it) -> {
- final Function1 _function_1 = (PAnnotation it_1) -> {
- String _name = it_1.getName();
- return Boolean.valueOf(Objects.equal(_name, "Constraint"));
- };
- return Boolean.valueOf(IterableExtensions.exists(it.getAllAnnotations(), _function_1));
- };
- final Set> wfPatterns = IterableExtensions.>toSet(IterableExtensions.>filter(patterns, _function));
- final Map, EStructuralFeature> derivedFeatures = CollectionLiterals., EStructuralFeature>emptyMap();
- final ViatraQuerySetDescriptor res = new ViatraQuerySetDescriptor(patterns, wfPatterns, derivedFeatures);
- return res;
- }
-
- public static void writeInterpretation(final LogicResult solution, final Logic2Ecore logic2Ecore, final ReasonerWorkspace workspace, final int i, final ViatraReasoner reasoner, final TracedOutput mgProb) {
- final List extends LogicModelInterpretation> interpretations = reasoner.getInterpretations(((ModelResult) solution));
- int _size = interpretations.size();
- ExclusiveRange _doubleDotLessThan = new ExclusiveRange(0, _size, true);
- for (final Integer interpIndex : _doubleDotLessThan) {
- {
- final LogicModelInterpretation interpretation = interpretations.get((interpIndex).intValue());
- final EObject model = logic2Ecore.transformInterpretation(interpretation, mgProb.getTrace());
- StringConcatenation _builder = new StringConcatenation();
- _builder.append("solution");
- _builder.append(i);
- _builder.append("_");
- _builder.append(interpIndex);
- _builder.append(".xmi");
- workspace.writeModel(model, _builder.toString());
- }
- }
- }
-
- public static void writeRepresentation(final LogicResult solution, final ReasonerWorkspace workspace, final int i) {
- final EList