From b3c1c5b30ae8ea7ebad391c9250b4509d5a4cc9b Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Tue, 19 May 2020 21:18:06 +0200 Subject: Config language WIP --- .../bin/queries/.FamilyTreeConstraints.java._trace | Bin 333 -> 773 bytes .../bin/queries/.MemberIsItsOwnParent.java._trace | Bin 3544 -> 3540 bytes .../bin/queries/.gitignore | 1 + .../bin/queries/familyTreeConstraints.vql | 44 +- .../case.study.familyTree.run/plugin.xml | 18 +- .../queries/.FamilyTreeConstraints.java._trace | Bin 333 -> 773 bytes .../queries/.MemberIsItsOwnParent.java._trace | Bin 3544 -> 3540 bytes .../src-gen/queries/.gitignore | 1 + .../src-gen/queries/FamilyTreeConstraints.java | 150 ++- .../src-gen/queries/MemberHasParent.java | 551 ++++++++++ .../src-gen/queries/MemberIsItsOwnParent.java | 1154 ++++++++++---------- .../src-gen/queries/NegativeAge.java | 593 ++++++++++ .../src-gen/queries/ParentTooYoung.java | 775 +++++++++++++ .../src-gen/queries/TwoMembersHaveNoParent.java | 723 ++++++++++++ .../xtend-gen/converter/.UML2TGF.xtendbin | Bin 6885 -> 6885 bytes .../xtend-gen/converter/.gitignore | 2 + .../case.study.pledge.run/bin/.gitignore | 1 + .../case.study.pledge.run/plugin.xml | 84 +- .../xtend-gen/run/.GeneratePledgeModels.xtendbin | Bin 16907 -> 16978 bytes 19 files changed, 3399 insertions(+), 698 deletions(-) create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberHasParent.java create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/NegativeAge.java create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java (limited to 'Tests/MODELS2020-CaseStudies') diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.FamilyTreeConstraints.java._trace b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.FamilyTreeConstraints.java._trace index 364eae66..b000501e 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.FamilyTreeConstraints.java._trace and b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.FamilyTreeConstraints.java._trace differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.MemberIsItsOwnParent.java._trace b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.MemberIsItsOwnParent.java._trace index 1b0dca98..aaf4d0c2 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.MemberIsItsOwnParent.java._trace and b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.MemberIsItsOwnParent.java._trace differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.gitignore index 3be531f5..3b9ccef7 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.gitignore +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/.gitignore @@ -6,3 +6,4 @@ /.MemberHasNoParent.java._trace /.MemberHasParent.java._trace /.TwoMembersHaveNoParent.java._trace +/.NegativeAge.java._trace diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/familyTreeConstraints.vql b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/familyTreeConstraints.vql index e7b44f0b..fdbac640 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/familyTreeConstraints.vql +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/familyTreeConstraints.vql @@ -9,25 +9,31 @@ pattern memberIsItsOwnParent(m: Member) = { m == p; } -//@Constraint(message="twoMembersHaveNoParent", severity="error", key={m1, m2}) -//pattern twoMembersHaveNoParent(m1:Member, m2:Member) = { -// neg find memberHasParent(m1); -// neg find memberHasParent(m2); -// m1 != m2; -//} -// -//pattern memberHasParent(m: Member) = { -// Member.parents(m, _); -//} -// -//@Constraint(message="parentTooYoung", severity="error", key={m, p}) -//pattern parentTooYoung(m: Member, p: Member) = { -// FamilyTree.members(_, m); -// Member.parents(m, p); -// Member.age(m, mAge); -// Member.age(p, pAge); -// check (mAge <= (pAge + 12)); -//} +@Constraint(message="twoMembersHaveNoParent", severity="error", key={m1, m2}) +pattern twoMembersHaveNoParent(m1:Member, m2:Member) = { + neg find memberHasParent(m1); + neg find memberHasParent(m2); + m1 != m2; +} + +pattern memberHasParent(m: Member) = { + Member.parents(m, _); +} + +@Constraint(message="negativeAge", severity="error",key={m}) +pattern negativeAge(m: Member) { + Member.age(m,mage); + check(mage<0); +} + +@Constraint(message="parentTooYoung", severity="error", key={c, p}) +pattern parentTooYoung(c: Member, p: Member) = { + FamilyTree.members(_, c); + Member.parents(c, p); + Member.age(c, cAge); + Member.age(p, pAge); + check (pAge <= (cAge + 12)); +} diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml index b32b0215..4297ec89 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml @@ -1,7 +1,11 @@ - - - - - - - + + + + + + + + + + + diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.FamilyTreeConstraints.java._trace b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.FamilyTreeConstraints.java._trace index 364eae66..b000501e 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.FamilyTreeConstraints.java._trace and b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.FamilyTreeConstraints.java._trace differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.MemberIsItsOwnParent.java._trace b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.MemberIsItsOwnParent.java._trace index 1b0dca98..aaf4d0c2 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.MemberIsItsOwnParent.java._trace and b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.MemberIsItsOwnParent.java._trace differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.gitignore index 3be531f5..3b9ccef7 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.gitignore +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.gitignore @@ -6,3 +6,4 @@ /.MemberHasNoParent.java._trace /.MemberHasParent.java._trace /.TwoMembersHaveNoParent.java._trace +/.NegativeAge.java._trace diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/FamilyTreeConstraints.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/FamilyTreeConstraints.java index a5c375c6..1d991140 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/FamilyTreeConstraints.java +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/FamilyTreeConstraints.java @@ -1,53 +1,97 @@ -/** - * 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.MemberIsItsOwnParent; - -/** - * 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 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()); - } - - public MemberIsItsOwnParent getMemberIsItsOwnParent() { - return MemberIsItsOwnParent.instance(); - } - - public MemberIsItsOwnParent.Matcher getMemberIsItsOwnParent(final ViatraQueryEngine engine) { - return MemberIsItsOwnParent.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.NegativeAge; +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 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(NegativeAge.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 NegativeAge getNegativeAge() { + return NegativeAge.instance(); + } + + public NegativeAge.Matcher getNegativeAge(final ViatraQueryEngine engine) { + return NegativeAge.Matcher.on(engine); + } + + public ParentTooYoung getParentTooYoung() { + return ParentTooYoung.instance(); + } + + public ParentTooYoung.Matcher getParentTooYoung(final ViatraQueryEngine engine) { + return ParentTooYoung.Matcher.on(engine); + } +} diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberHasParent.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberHasParent.java new file mode 100644 index 00000000..83bb4aac --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/MemberHasParent.java @@ -0,0 +1,551 @@ +/** + * 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. + * + *

Original source: + * 

+ *         pattern memberHasParent(m: Member) = {
+ *         	Member.parents(m, _);
+ *         }
+ *
+ * + * @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}. + * + *

Original source: + * 

+   * pattern memberHasParent(m: Member) = {
+   * 	Member.parents(m, _);
+   * }
+   *
+ * + * @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 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. - * - *

Original source: - * 

- *         {@literal @}Constraint(message="memberIsItsOwnParent", severity="error", key={m})
- *         pattern memberIsItsOwnParent(m: Member) = {
- *         	FamilyTree.members(_, m);
- *         	Member.parents(m, p);
- *         	m == p;
- *         }
- *
- * - * @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}. - * - *

Original source: - * 

-   * {@literal @}Constraint(message="memberIsItsOwnParent", severity="error", key={m})
-   * pattern memberIsItsOwnParent(m: Member) = {
-   * 	FamilyTree.members(_, m);
-   * 	Member.parents(m, p);
-   * 	m == p;
-   * }
-   *
- * - * @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 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. + * + *

Original source: + * 

+ *         {@literal @}Constraint(message="memberIsItsOwnParent", severity="error", key={m})
+ *         pattern memberIsItsOwnParent(m: Member) = {
+ *         	FamilyTree.members(_, m);
+ *         	Member.parents(m, p);
+ *         	m == p;
+ *         }
+ *
+ * + * @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}. + * + *

Original source: + * 

+   * {@literal @}Constraint(message="memberIsItsOwnParent", severity="error", key={m})
+   * pattern memberIsItsOwnParent(m: Member) = {
+   * 	FamilyTree.members(_, m);
+   * 	Member.parents(m, p);
+   * 	m == p;
+   * }
+   *
+ * + * @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 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/NegativeAge.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/NegativeAge.java new file mode 100644 index 00000000..44ae6496 --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/NegativeAge.java @@ -0,0 +1,593 @@ +/** + * 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. + * + *

Original source: + * 

+ *         {@literal @}Constraint(message="negativeAge", severity="error",key={m})
+ *         pattern negativeAge(m: Member) {
+ *         	Member.age(m,mage);
+ *         	check(mage{@literal <}0);
+ *         }
+ *
+ * + * @see Matcher + * @see Match + * + */ +@SuppressWarnings("all") +public final class NegativeAge extends BaseGeneratedEMFQuerySpecification { + /** + * Pattern-specific match representation of the queries.negativeAge 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.negativeAge"; + } + + @Override + public List parameterNames() { + return NegativeAge.Match.parameterNames; + } + + @Override + public Object[] toArray() { + return new Object[]{fM}; + } + + @Override + public NegativeAge.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 NegativeAge.Match)) { + NegativeAge.Match other = (NegativeAge.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 NegativeAge specification() { + return NegativeAge.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 NegativeAge.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 NegativeAge.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 NegativeAge.Match newMatch(final Member pM) { + return new Immutable(pM); + } + + private static final class Mutable extends NegativeAge.Match { + Mutable(final Member pM) { + super(pM); + } + + @Override + public boolean isMutable() { + return true; + } + } + + private static final class Immutable extends NegativeAge.Match { + Immutable(final Member pM) { + super(pM); + } + + @Override + public boolean isMutable() { + return false; + } + } + } + + /** + * Generated pattern matcher API of the queries.negativeAge 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}. + * + *

Original source: + * 

+   * {@literal @}Constraint(message="negativeAge", severity="error",key={m})
+   * pattern negativeAge(m: Member) {
+   * 	Member.age(m,mage);
+   * 	check(mage{@literal <}0);
+   * }
+   *
+ * + * @see Match + * @see NegativeAge + * + */ + 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 NegativeAge.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 NegativeAge.Matcher create() { + return new Matcher(); + } + + private static final int POSITION_M = 0; + + private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(NegativeAge.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 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 NegativeAge.Match newMatch(final Member pM) { + return NegativeAge.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 NegativeAge.Match tupleToMatch(final Tuple t) { + try { + return NegativeAge.Match.newMatch((Member) t.get(POSITION_M)); + } catch(ClassCastException e) { + LOGGER.error("Element(s) in tuple not properly typed!",e); + return null; + } + } + + @Override + protected NegativeAge.Match arrayToMatch(final Object[] match) { + try { + return NegativeAge.Match.newMatch((Member) match[POSITION_M]); + } catch(ClassCastException e) { + LOGGER.error("Element(s) in array not properly typed!",e); + return null; + } + } + + @Override + protected NegativeAge.Match arrayToMatchMutable(final Object[] match) { + try { + return NegativeAge.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 NegativeAge.instance(); + } + } + + private NegativeAge() { + super(GeneratedPQuery.INSTANCE); + } + + /** + * @return the singleton instance of the query specification + * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded + * + */ + public static NegativeAge instance() { + try{ + return LazyHolder.INSTANCE; + } catch (ExceptionInInitializerError err) { + throw processInitializerError(err); + } + } + + @Override + protected NegativeAge.Matcher instantiate(final ViatraQueryEngine engine) { + return NegativeAge.Matcher.on(engine); + } + + @Override + public NegativeAge.Matcher instantiate() { + return NegativeAge.Matcher.create(); + } + + @Override + public NegativeAge.Match newEmptyMatch() { + return NegativeAge.Match.newEmptyMatch(); + } + + @Override + public NegativeAge.Match newMatch(final Object... parameters) { + return NegativeAge.Match.newMatch((familytree.Member) parameters[0]); + } + + /** + * Inner class allowing the singleton instance of {@link NegativeAge} to be created + * not at the class load time of the outer class, + * but rather at the first call to {@link NegativeAge#instance()}. + * + *

This workaround is required e.g. to support recursion. + * + */ + private static class LazyHolder { + private static final NegativeAge INSTANCE = new NegativeAge(); + + /** + * 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 NegativeAge.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.negativeAge"; + } + + @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_mage = body.getOrCreateVariableByName("mage"); + 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.age(m,mage) + 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", "age"))); + new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt"))); + new Equality(body, var__virtual_0_, var_mage); + // check(mage<0) + new ExpressionEvaluation(body, new IExpressionEvaluator() { + + @Override + public String getShortDescription() { + return "Expression evaluation from pattern negativeAge"; + } + + @Override + public Iterable getInputParameterNames() { + return Arrays.asList("mage");} + + @Override + public Object evaluateExpression(IValueProvider provider) throws Exception { + Integer mage = (Integer) provider.getValue("mage"); + return evaluateExpression_1_1(mage); + } + }, null); + bodies.add(body); + } + { + PAnnotation annotation = new PAnnotation("Constraint"); + annotation.addAttribute("message", "negativeAge"); + annotation.addAttribute("severity", "error"); + annotation.addAttribute("key", Arrays.asList(new Object[] { + new ParameterReference("m") + })); + addAnnotation(annotation); + } + return bodies; + } + } + + private static boolean evaluateExpression_1_1(final Integer mage) { + return ((mage).intValue() < 0); + } +} 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 new file mode 100644 index 00000000..5ed9df5e --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java @@ -0,0 +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. + * + *

Original source: + * 

+ *         {@literal @}Constraint(message="parentTooYoung", severity="error", key={c, p})
+ *         pattern parentTooYoung(c: Member, p: Member) = {
+ *         	FamilyTree.members(_, c);
+ *         	Member.parents(c, p);
+ *         	Member.age(c, cAge);
+ *         	Member.age(p, pAge);
+ *         	check (pAge {@literal <}= (cAge + 12));
+ *         }
+ *
+ * + * @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 fC; + + private Member fP; + + private static List parameterNames = makeImmutableList("c", "p"); + + private Match(final Member pC, final Member pP) { + this.fC = pC; + this.fP = pP; + } + + @Override + public Object get(final String parameterName) { + switch(parameterName) { + case "c": return this.fC; + case "p": return this.fP; + default: return null; + } + } + + @Override + public Object get(final int index) { + switch(index) { + case 0: return this.fC; + case 1: return this.fP; + default: return null; + } + } + + public Member getC() { + return this.fC; + } + + public Member getP() { + return this.fP; + } + + @Override + public boolean set(final String parameterName, final Object newValue) { + if (!isMutable()) throw new java.lang.UnsupportedOperationException(); + if ("c".equals(parameterName) ) { + this.fC = (Member) newValue; + return true; + } + if ("p".equals(parameterName) ) { + this.fP = (Member) newValue; + return true; + } + return false; + } + + public void setC(final Member pC) { + if (!isMutable()) throw new java.lang.UnsupportedOperationException(); + this.fC = pC; + } + + 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[]{fC, fP}; + } + + @Override + public ParentTooYoung.Match toImmutable() { + return isMutable() ? newMatch(fC, fP) : this; + } + + @Override + public String prettyPrint() { + StringBuilder result = new StringBuilder(); + result.append("\"c\"=" + prettyPrintValue(fC) + ", "); + result.append("\"p\"=" + prettyPrintValue(fP)); + return result.toString(); + } + + @Override + public int hashCode() { + return Objects.hash(fC, 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(fC, other.fC) && 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return new Mutable(pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return new Immutable(pC, pP); + } + + private static final class Mutable extends ParentTooYoung.Match { + Mutable(final Member pC, final Member pP) { + super(pC, pP); + } + + @Override + public boolean isMutable() { + return true; + } + } + + private static final class Immutable extends ParentTooYoung.Match { + Immutable(final Member pC, final Member pP) { + super(pC, 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}. + * + *

Original source: + * 

+   * {@literal @}Constraint(message="parentTooYoung", severity="error", key={c, p})
+   * pattern parentTooYoung(c: Member, p: Member) = {
+   * 	FamilyTree.members(_, c);
+   * 	Member.parents(c, p);
+   * 	Member.age(c, cAge);
+   * 	Member.age(p, pAge);
+   * 	check (pAge {@literal <}= (cAge + 12));
+   * }
+   *
+ * + * @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_C = 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return rawStreamAllMatches(new Object[]{pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return rawStreamAllMatches(new Object[]{pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return rawGetOneArbitraryMatch(new Object[]{pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return rawHasMatch(new Object[]{pC, pP}); + } + + /** + * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters. + * @param pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return rawCountMatches(new Object[]{pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP, final Consumer processor) { + return rawForOneArbitraryMatch(new Object[]{pC, 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 pC the fixed value of pattern parameter c, 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 pC, final Member pP) { + return ParentTooYoung.Match.newMatch(pC, pP); + } + + /** + * Retrieve the set of values that occur in matches for c. + * @return the Set of all values or empty set if there are no matches + * + */ + protected Stream rawStreamAllValuesOfc(final Object[] parameters) { + return rawStreamAllValues(POSITION_C, parameters).map(Member.class::cast); + } + + /** + * Retrieve the set of values that occur in matches for c. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfc() { + return rawStreamAllValuesOfc(emptyArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for c. + * @return the Set of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfc() { + return rawStreamAllValuesOfc(emptyArray()); + } + + /** + * Retrieve the set of values that occur in matches for c. + *

+ * 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 streamAllValuesOfc(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfc(partialMatch.toArray()); + } + + /** + * Retrieve the set of values that occur in matches for c. + *

+ * 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 streamAllValuesOfc(final Member pP) { + return rawStreamAllValuesOfc(new Object[]{null, pP}); + } + + /** + * Retrieve the set of values that occur in matches for c. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfc(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfc(partialMatch.toArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for c. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfc(final Member pP) { + return rawStreamAllValuesOfc(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 pC) { + return rawStreamAllValuesOfp(new Object[]{pC, 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 pC) { + return rawStreamAllValuesOfp(new Object[]{pC, null}).collect(Collectors.toSet()); + } + + @Override + protected ParentTooYoung.Match tupleToMatch(final Tuple t) { + try { + return ParentTooYoung.Match.newMatch((Member) t.get(POSITION_C), (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_C], (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_C], (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_c = new PParameter("c", "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_c, parameter_p); + + private GeneratedPQuery() { + super(PVisibility.PUBLIC); + } + + @Override + public String getFullyQualifiedName() { + return "queries.parentTooYoung"; + } + + @Override + public List getParameterNames() { + return Arrays.asList("c","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_c = body.getOrCreateVariableByName("c"); + PVariable var_p = body.getOrCreateVariableByName("p"); + PVariable var___0_ = body.getOrCreateVariableByName("_<0>"); + PVariable var_cAge = body.getOrCreateVariableByName("cAge"); + PVariable var_pAge = body.getOrCreateVariableByName("pAge"); + new TypeConstraint(body, Tuples.flatTupleOf(var_c), 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_c, parameter_c), + new ExportedParameter(body, var_p, parameter_p) + )); + // FamilyTree.members(_, c) + 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_c); + // Member.parents(c, p) + new TypeConstraint(body, Tuples.flatTupleOf(var_c), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}"); + new TypeConstraint(body, Tuples.flatTupleOf(var_c, 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(c, cAge) + new TypeConstraint(body, Tuples.flatTupleOf(var_c), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}"); + new TypeConstraint(body, Tuples.flatTupleOf(var_c, 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_cAge); + // 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 (pAge <= (cAge + 12)) + new ExpressionEvaluation(body, new IExpressionEvaluator() { + + @Override + public String getShortDescription() { + return "Expression evaluation from pattern parentTooYoung"; + } + + @Override + public Iterable getInputParameterNames() { + return Arrays.asList("cAge", "pAge");} + + @Override + public Object evaluateExpression(IValueProvider provider) throws Exception { + Integer cAge = (Integer) provider.getValue("cAge"); + Integer pAge = (Integer) provider.getValue("pAge"); + return evaluateExpression_1_1(cAge, 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("c"), + new ParameterReference("p") + })); + addAnnotation(annotation); + } + return bodies; + } + } + + private static boolean evaluateExpression_1_1(final Integer cAge, final Integer pAge) { + return ((pAge).intValue() <= ((cAge).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 new file mode 100644 index 00000000..365939dd --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java @@ -0,0 +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. + * + *

Original source: + * 

+ *         {@literal @}Constraint(message="twoMembersHaveNoParent", severity="error", key={m1, m2})
+ *         pattern twoMembersHaveNoParent(m1:Member, m2:Member) = {
+ *         	neg find memberHasParent(m1);
+ *         	neg find memberHasParent(m2);
+ *         	m1 != m2;
+ *         }
+ *
+ * + * @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}. + * + *

Original source: + * 

+   * {@literal @}Constraint(message="twoMembersHaveNoParent", severity="error", key={m1, m2})
+   * pattern twoMembersHaveNoParent(m1:Member, m2:Member) = {
+   * 	neg find memberHasParent(m1);
+   * 	neg find memberHasParent(m2);
+   * 	m1 != m2;
+   * }
+   *
+ * + * @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 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.originalFiles/xtend-gen/converter/.UML2TGF.xtendbin b/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.UML2TGF.xtendbin index 2890feb7..d5f0c05c 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.UML2TGF.xtendbin and b/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.UML2TGF.xtendbin differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.gitignore index 2df5d1c0..7a39cb70 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.gitignore +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.originalFiles/xtend-gen/converter/.gitignore @@ -1 +1,3 @@ /.UML2TGF.java._trace +/.UML2TGF.xtendbin +/UML2TGF.java diff --git a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/bin/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/bin/.gitignore index 07e30191..e8806810 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.pledge.run/bin/.gitignore +++ b/Tests/MODELS2020-CaseStudies/case.study.pledge.run/bin/.gitignore @@ -1 +1,2 @@ /run/ +/queries/ 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 c5572067..0b00309c 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 -- cgit v1.2.3-70-g09d2