From e44d27fde5c3b6c933ea3de33781f6ad03d6545b Mon Sep 17 00:00:00 2001 From: ArenBabikian Date: Wed, 6 May 2020 16:16:57 -0400 Subject: Adjustments to FamilyTree and Pledge Case studies --- .../bin/queries/.FamilyTreeConstraints.java._trace | Bin 333 -> 632 bytes .../bin/queries/familyTreeConstraints.vql | 27 +- .../outputs/debug/errors.txt | 16 + .../outputs/debug/generation.logicproblem | 154 +++- .../case.study.familyTree.run/outputs/log.txt | 2 +- .../case.study.familyTree.run/outputs/models/1.gml | 76 +- .../case.study.familyTree.run/outputs/models/1.png | Bin 93940 -> 97536 bytes .../case.study.familyTree.run/outputs/models/1.xmi | 8 +- .../case.study.familyTree.run/plugin.xml | 3 + .../queries/.FamilyTreeConstraints.java._trace | Bin 333 -> 632 bytes .../src-gen/queries/.gitignore | 4 + .../src-gen/queries/FamilyTreeConstraints.java | 33 + .../src-gen/queries/MemberHasParent.java | 551 +++++++++++++++ .../src-gen/queries/ParentTooYoung.java | 775 +++++++++++++++++++++ .../src-gen/queries/TwoMembersHaveNoParent.java | 723 +++++++++++++++++++ .../src/queries/familyTreeConstraints.vql | 27 +- 16 files changed, 2319 insertions(+), 80 deletions(-) create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/errors.txt 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/ParentTooYoung.java create mode 100644 Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java (limited to 'Tests/MODELS2020-CaseStudies/case.study.familyTree.run') 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 80158bd8..12849bfe 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/familyTreeConstraints.vql b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/bin/queries/familyTreeConstraints.vql index 1b9b6659..a204443a 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,14 +9,25 @@ pattern memberIsItsOwnParent(m: Member) = { m == p; } -//@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="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)); +} diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/errors.txt b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/errors.txt new file mode 100644 index 00000000..b7eed629 --- /dev/null +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/errors.txt @@ -0,0 +1,16 @@ +Error occured (NullPointerException): + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PConstraintTransformer.hasValueExpression(PConstraintTransformer.java:487) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PConstraintTransformer._transformConstraint(PConstraintTransformer.java:614) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PConstraintTransformer.transformConstraint(PConstraintTransformer.java:689) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.RelationDefinitionIndexer.transformPattern(RelationDefinitionIndexer.java:169) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.RelationDefinitionIndexer.generateRelationDefinitions(RelationDefinitionIndexer.java:51) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternGenerator.transformBaseProperties(PatternGenerator.java:747) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.PatternProvider.generateQueries(PatternProvider.java:59) + hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethodProvider.createModelGenerationMethod(ModelGenerationMethodProvider.java:57) + hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ViatraReasoner.solve(ViatraReasoner.java:96) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:316) + hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor._execute(ScriptExecutor.java:129) + hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.execute(ScriptExecutor.java:338) + hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.executeScript(ScriptExecutor.java:110) + hu.bme.mit.inf.dslreasoner.application.execution.StandaloneScriptExecutor.executeScript(StandaloneScriptExecutor.java:149) + run.FamilyTreeGen.main(FamilyTreeGen.java:7) diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/generation.logicproblem b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/generation.logicproblem index dd3b15b1..327ce8b0 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/generation.logicproblem +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/debug/generation.logicproblem @@ -123,7 +123,7 @@ - + @@ -135,6 +135,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -178,7 +210,114 @@ - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -186,5 +325,16 @@ + + + + + + + + + + + diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/log.txt b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/log.txt index 6186ec60..43befb00 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/log.txt +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/log.txt @@ -1 +1 @@ -Model generation finished +Model generation started diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.gml b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.gml index 0182add9..88392428 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.gml +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.gml @@ -667,8 +667,8 @@ graph ] edge [ - source 9 - target 8 + source 8 + target 9 graphics [ fill "#000000" @@ -686,8 +686,8 @@ graph ] edge [ - source 8 - target 9 + source 9 + target 8 graphics [ fill "#000000" @@ -706,7 +706,7 @@ graph edge [ source 10 - target 11 + target 9 graphics [ fill "#000000" @@ -724,8 +724,8 @@ graph ] edge [ - source 8 - target 10 + source 10 + target 8 graphics [ fill "#000000" @@ -743,8 +743,8 @@ graph ] edge [ - source 11 - target 9 + source 9 + target 10 graphics [ fill "#000000" @@ -781,7 +781,7 @@ graph ] edge [ - source 10 + source 9 target 8 graphics [ @@ -790,7 +790,7 @@ graph ] LabelGraphics [ - text "children reference Member" + text "parents reference Member" fontSize 14 fontName "Consolas" configuration "AutoFlippingLabel" @@ -820,7 +820,7 @@ graph edge [ source 9 - target 8 + target 10 graphics [ fill "#000000" @@ -838,7 +838,7 @@ graph ] edge [ - source 11 + source 8 target 10 graphics [ @@ -858,26 +858,7 @@ graph edge [ source 10 - target 8 - graphics - [ - fill "#000000" - targetArrow "standard" - ] - LabelGraphics - [ - text "parents reference Member" - fontSize 14 - fontName "Consolas" - configuration "AutoFlippingLabel" - model "six_pos" - position "thead" - ] - ] - edge - [ - source 9 - target 11 + target 9 graphics [ fill "#000000" @@ -914,27 +895,8 @@ graph ] edge [ - source 8 - target 10 - graphics - [ - fill "#000000" - targetArrow "standard" - ] - LabelGraphics - [ - text "parents reference Member" - fontSize 14 - fontName "Consolas" - configuration "AutoFlippingLabel" - model "six_pos" - position "thead" - ] - ] - edge - [ - source 8 - target 6 + source 9 + target 5 graphics [ fill "#000000" @@ -952,7 +914,7 @@ graph ] edge [ - source 9 + source 8 target 5 graphics [ @@ -972,7 +934,7 @@ graph edge [ source 10 - target 2 + target 5 graphics [ fill "#000000" @@ -991,7 +953,7 @@ graph edge [ source 11 - target 4 + target 6 graphics [ fill "#000000" diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.png b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.png index 391d902b..4c0da9fb 100644 Binary files a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.png and b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.png differ diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.xmi b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.xmi index 11e0e7c3..25c5bfed 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.xmi +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/outputs/models/1.xmi @@ -1,8 +1,8 @@ - + + + - - - + diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml index b32b0215..9364ebb2 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/plugin.xml @@ -2,6 +2,9 @@ + + + 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 80158bd8..12849bfe 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/.gitignore b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/.gitignore index 1641b3f8..3be531f5 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 @@ -2,3 +2,7 @@ /.MemberIsItsOwnParent.java._trace /FamilyTreeConstraints.java /MemberIsItsOwnParent.java +/.ParentTooYoung.java._trace +/.MemberHasNoParent.java._trace +/.MemberHasParent.java._trace +/.TwoMembersHaveNoParent.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..738b41c0 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 @@ -5,7 +5,10 @@ package queries; import org.eclipse.viatra.query.runtime.api.ViatraQueryEngine; import org.eclipse.viatra.query.runtime.api.impl.BaseGeneratedPatternGroup; +import queries.MemberHasParent; import queries.MemberIsItsOwnParent; +import queries.ParentTooYoung; +import queries.TwoMembersHaveNoParent; /** * A pattern group formed of all public patterns defined in familyTreeConstraints.vql. @@ -16,6 +19,9 @@ import queries.MemberIsItsOwnParent; * *

From package queries, the group contains the definition of the following patterns:

    *
  • memberIsItsOwnParent
    • + *
  • twoMembersHaveNoParent
    • + *
  • memberHasParent
    • + *
  • parentTooYoung
    • *
* * @see IQueryGroup @@ -41,6 +47,9 @@ public final class FamilyTreeConstraints extends BaseGeneratedPatternGroup { private FamilyTreeConstraints() { querySpecifications.add(MemberIsItsOwnParent.instance()); + querySpecifications.add(TwoMembersHaveNoParent.instance()); + querySpecifications.add(MemberHasParent.instance()); + querySpecifications.add(ParentTooYoung.instance()); } public MemberIsItsOwnParent getMemberIsItsOwnParent() { @@ -50,4 +59,28 @@ public final class FamilyTreeConstraints extends BaseGeneratedPatternGroup { public MemberIsItsOwnParent.Matcher getMemberIsItsOwnParent(final ViatraQueryEngine engine) { return MemberIsItsOwnParent.Matcher.on(engine); } + + public TwoMembersHaveNoParent getTwoMembersHaveNoParent() { + return TwoMembersHaveNoParent.instance(); + } + + public TwoMembersHaveNoParent.Matcher getTwoMembersHaveNoParent(final ViatraQueryEngine engine) { + return TwoMembersHaveNoParent.Matcher.on(engine); + } + + public MemberHasParent getMemberHasParent() { + return MemberHasParent.instance(); + } + + public MemberHasParent.Matcher getMemberHasParent(final ViatraQueryEngine engine) { + return MemberHasParent.Matcher.on(engine); + } + + public ParentTooYoung getParentTooYoung() { + return ParentTooYoung.instance(); + } + + public ParentTooYoung.Matcher getParentTooYoung(final ViatraQueryEngine engine) { + return ParentTooYoung.Matcher.on(engine); + } } 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..82b83d0c --- /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/ParentTooYoung.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/ParentTooYoung.java new file mode 100644 index 00000000..e90186e2 --- /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={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 {@literal <}= (pAge + 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 fM; + + private Member fP; + + private static List parameterNames = makeImmutableList("m", "p"); + + private Match(final Member pM, final Member pP) { + this.fM = pM; + this.fP = pP; + } + + @Override + public Object get(final String parameterName) { + switch(parameterName) { + case "m": return this.fM; + case "p": return this.fP; + default: return null; + } + } + + @Override + public Object get(final int index) { + switch(index) { + case 0: return this.fM; + case 1: return this.fP; + default: return null; + } + } + + public Member getM() { + return this.fM; + } + + public Member getP() { + return this.fP; + } + + @Override + public boolean set(final String parameterName, final Object newValue) { + if (!isMutable()) throw new java.lang.UnsupportedOperationException(); + if ("m".equals(parameterName) ) { + this.fM = (Member) newValue; + return true; + } + if ("p".equals(parameterName) ) { + this.fP = (Member) newValue; + return true; + } + return false; + } + + public void setM(final Member pM) { + if (!isMutable()) throw new java.lang.UnsupportedOperationException(); + this.fM = pM; + } + + public void setP(final Member pP) { + if (!isMutable()) throw new java.lang.UnsupportedOperationException(); + this.fP = pP; + } + + @Override + public String patternName() { + return "queries.parentTooYoung"; + } + + @Override + public List parameterNames() { + return ParentTooYoung.Match.parameterNames; + } + + @Override + public Object[] toArray() { + return new Object[]{fM, fP}; + } + + @Override + public ParentTooYoung.Match toImmutable() { + return isMutable() ? newMatch(fM, fP) : this; + } + + @Override + public String prettyPrint() { + StringBuilder result = new StringBuilder(); + result.append("\"m\"=" + prettyPrintValue(fM) + ", "); + result.append("\"p\"=" + prettyPrintValue(fP)); + return result.toString(); + } + + @Override + public int hashCode() { + return Objects.hash(fM, fP); + } + + @Override + public boolean equals(final Object obj) { + if (this == obj) + return true; + if (obj == null) { + return false; + } + if ((obj instanceof ParentTooYoung.Match)) { + ParentTooYoung.Match other = (ParentTooYoung.Match) obj; + return Objects.equals(fM, other.fM) && Objects.equals(fP, other.fP); + } else { + // this should be infrequent + if (!(obj instanceof IPatternMatch)) { + return false; + } + IPatternMatch otherSig = (IPatternMatch) obj; + return Objects.equals(specification(), otherSig.specification()) && Arrays.deepEquals(toArray(), otherSig.toArray()); + } + } + + @Override + public ParentTooYoung specification() { + return ParentTooYoung.instance(); + } + + /** + * Returns an empty, mutable match. + * Fields of the mutable match can be filled to create a partial match, usable as matcher input. + * + * @return the empty match. + * + */ + public static ParentTooYoung.Match newEmptyMatch() { + return new Mutable(null, null); + } + + /** + * Returns a mutable (partial) match. + * Fields of the mutable match can be filled to create a partial match, usable as matcher input. + * + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return the new, mutable (partial) match object. + * + */ + public static ParentTooYoung.Match newMutableMatch(final Member pM, final Member pP) { + return new Mutable(pM, pP); + } + + /** + * Returns a new (partial) match. + * This can be used e.g. to call the matcher with a partial match. + *

The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return the (partial) match object. + * + */ + public static ParentTooYoung.Match newMatch(final Member pM, final Member pP) { + return new Immutable(pM, pP); + } + + private static final class Mutable extends ParentTooYoung.Match { + Mutable(final Member pM, final Member pP) { + super(pM, pP); + } + + @Override + public boolean isMutable() { + return true; + } + } + + private static final class Immutable extends ParentTooYoung.Match { + Immutable(final Member pM, final Member pP) { + super(pM, pP); + } + + @Override + public boolean isMutable() { + return false; + } + } + } + + /** + * Generated pattern matcher API of the queries.parentTooYoung pattern, + * providing pattern-specific query methods. + * + *

Use the pattern matcher on a given model via {@link #on(ViatraQueryEngine)}, + * e.g. in conjunction with {@link ViatraQueryEngine#on(QueryScope)}. + * + *

Matches of the pattern will be represented as {@link Match}. + * + *

Original source: + * 

+   * {@literal @}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 {@literal <}= (pAge + 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_M = 0; + + private static final int POSITION_P = 1; + + private static final Logger LOGGER = ViatraQueryLoggingUtil.getLogger(ParentTooYoung.Matcher.class); + + /** + * Initializes the pattern matcher within an existing VIATRA Query engine. + * If the pattern matcher is already constructed in the engine, only a light-weight reference is returned. + * + * @param engine the existing VIATRA Query engine in which this matcher will be created. + * @throws ViatraQueryRuntimeException if an error occurs during pattern matcher creation + * + */ + private Matcher() { + super(querySpecification()); + } + + /** + * Returns the set of all matches of the pattern that conform to the given fixed values of some parameters. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return matches represented as a Match object. + * + */ + public Collection getAllMatches(final Member pM, final Member pP) { + return rawStreamAllMatches(new Object[]{pM, pP}).collect(Collectors.toSet()); + } + + /** + * Returns a stream of all matches of the pattern that conform to the given fixed values of some parameters. + *

+ * NOTE: It is important not to modify the source model while the stream is being processed. + * If the match set of the pattern changes during processing, the contents of the stream is undefined. + * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return a stream of matches represented as a Match object. + * + */ + public Stream streamAllMatches(final Member pM, final Member pP) { + return rawStreamAllMatches(new Object[]{pM, pP}); + } + + /** + * Returns an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters. + * Neither determinism nor randomness of selection is guaranteed. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return a match represented as a Match object, or null if no match is found. + * + */ + public Optional getOneArbitraryMatch(final Member pM, final Member pP) { + return rawGetOneArbitraryMatch(new Object[]{pM, pP}); + } + + /** + * Indicates whether the given combination of specified pattern parameters constitute a valid pattern match, + * under any possible substitution of the unspecified parameters (if any). + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return true if the input is a valid (partial) match of the pattern. + * + */ + public boolean hasMatch(final Member pM, final Member pP) { + return rawHasMatch(new Object[]{pM, pP}); + } + + /** + * Returns the number of all matches of the pattern that conform to the given fixed values of some parameters. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return the number of pattern matches found. + * + */ + public int countMatches(final Member pM, final Member pP) { + return rawCountMatches(new Object[]{pM, pP}); + } + + /** + * Executes the given processor on an arbitrarily chosen match of the pattern that conforms to the given fixed values of some parameters. + * Neither determinism nor randomness of selection is guaranteed. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @param processor the action that will process the selected match. + * @return true if the pattern has at least one match with the given parameter values, false if the processor was not invoked + * + */ + public boolean forOneArbitraryMatch(final Member pM, final Member pP, final Consumer processor) { + return rawForOneArbitraryMatch(new Object[]{pM, pP}, processor); + } + + /** + * Returns a new (partial) match. + * This can be used e.g. to call the matcher with a partial match. + *

The returned match will be immutable. Use {@link #newEmptyMatch()} to obtain a mutable match object. + * @param pM the fixed value of pattern parameter m, or null if not bound. + * @param pP the fixed value of pattern parameter p, or null if not bound. + * @return the (partial) match object. + * + */ + public ParentTooYoung.Match newMatch(final Member pM, final Member pP) { + return ParentTooYoung.Match.newMatch(pM, pP); + } + + /** + * Retrieve the set of values that occur in matches for m. + * @return the Set of all values or empty set if there are no matches + * + */ + protected Stream rawStreamAllValuesOfm(final Object[] parameters) { + return rawStreamAllValues(POSITION_M, parameters).map(Member.class::cast); + } + + /** + * Retrieve the set of values that occur in matches for m. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfm() { + return rawStreamAllValuesOfm(emptyArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for m. + * @return the Set of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfm() { + return rawStreamAllValuesOfm(emptyArray()); + } + + /** + * Retrieve the set of values that occur in matches for m. + *

+ * NOTE: It is important not to modify the source model while the stream is being processed. + * If the match set of the pattern changes during processing, the contents of the stream is undefined. + * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code. + * + * @return the Stream of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfm(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfm(partialMatch.toArray()); + } + + /** + * Retrieve the set of values that occur in matches for m. + *

+ * NOTE: It is important not to modify the source model while the stream is being processed. + * If the match set of the pattern changes during processing, the contents of the stream is undefined. + * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code. + * + * @return the Stream of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfm(final Member pP) { + return rawStreamAllValuesOfm(new Object[]{null, pP}); + } + + /** + * Retrieve the set of values that occur in matches for m. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfm(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfm(partialMatch.toArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for m. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfm(final Member pP) { + return rawStreamAllValuesOfm(new Object[]{null, pP}).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for p. + * @return the Set of all values or empty set if there are no matches + * + */ + protected Stream rawStreamAllValuesOfp(final Object[] parameters) { + return rawStreamAllValues(POSITION_P, parameters).map(Member.class::cast); + } + + /** + * Retrieve the set of values that occur in matches for p. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfp() { + return rawStreamAllValuesOfp(emptyArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for p. + * @return the Set of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfp() { + return rawStreamAllValuesOfp(emptyArray()); + } + + /** + * Retrieve the set of values that occur in matches for p. + *

+ * NOTE: It is important not to modify the source model while the stream is being processed. + * If the match set of the pattern changes during processing, the contents of the stream is undefined. + * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code. + * + * @return the Stream of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfp(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfp(partialMatch.toArray()); + } + + /** + * Retrieve the set of values that occur in matches for p. + *

+ * NOTE: It is important not to modify the source model while the stream is being processed. + * If the match set of the pattern changes during processing, the contents of the stream is undefined. + * In such cases, either rely on {@link #getAllMatches()} or collect the results of the stream in end-user code. + * + * @return the Stream of all values or empty set if there are no matches + * + */ + public Stream streamAllValuesOfp(final Member pM) { + return rawStreamAllValuesOfp(new Object[]{pM, null}); + } + + /** + * Retrieve the set of values that occur in matches for p. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfp(final ParentTooYoung.Match partialMatch) { + return rawStreamAllValuesOfp(partialMatch.toArray()).collect(Collectors.toSet()); + } + + /** + * Retrieve the set of values that occur in matches for p. + * @return the Set of all values or empty set if there are no matches + * + */ + public Set getAllValuesOfp(final Member pM) { + return rawStreamAllValuesOfp(new Object[]{pM, null}).collect(Collectors.toSet()); + } + + @Override + protected ParentTooYoung.Match tupleToMatch(final Tuple t) { + try { + return ParentTooYoung.Match.newMatch((Member) t.get(POSITION_M), (Member) t.get(POSITION_P)); + } catch(ClassCastException e) { + LOGGER.error("Element(s) in tuple not properly typed!",e); + return null; + } + } + + @Override + protected ParentTooYoung.Match arrayToMatch(final Object[] match) { + try { + return ParentTooYoung.Match.newMatch((Member) match[POSITION_M], (Member) match[POSITION_P]); + } catch(ClassCastException e) { + LOGGER.error("Element(s) in array not properly typed!",e); + return null; + } + } + + @Override + protected ParentTooYoung.Match arrayToMatchMutable(final Object[] match) { + try { + return ParentTooYoung.Match.newMutableMatch((Member) match[POSITION_M], (Member) match[POSITION_P]); + } catch(ClassCastException e) { + LOGGER.error("Element(s) in array not properly typed!",e); + return null; + } + } + + /** + * @return the singleton instance of the query specification of this pattern + * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded + * + */ + public static IQuerySpecification querySpecification() { + return ParentTooYoung.instance(); + } + } + + private ParentTooYoung() { + super(GeneratedPQuery.INSTANCE); + } + + /** + * @return the singleton instance of the query specification + * @throws ViatraQueryRuntimeException if the pattern definition could not be loaded + * + */ + public static ParentTooYoung instance() { + try{ + return LazyHolder.INSTANCE; + } catch (ExceptionInInitializerError err) { + throw processInitializerError(err); + } + } + + @Override + protected ParentTooYoung.Matcher instantiate(final ViatraQueryEngine engine) { + return ParentTooYoung.Matcher.on(engine); + } + + @Override + public ParentTooYoung.Matcher instantiate() { + return ParentTooYoung.Matcher.create(); + } + + @Override + public ParentTooYoung.Match newEmptyMatch() { + return ParentTooYoung.Match.newEmptyMatch(); + } + + @Override + public ParentTooYoung.Match newMatch(final Object... parameters) { + return ParentTooYoung.Match.newMatch((familytree.Member) parameters[0], (familytree.Member) parameters[1]); + } + + /** + * Inner class allowing the singleton instance of {@link ParentTooYoung} to be created + * not at the class load time of the outer class, + * but rather at the first call to {@link ParentTooYoung#instance()}. + * + *

This workaround is required e.g. to support recursion. + * + */ + private static class LazyHolder { + private static final ParentTooYoung INSTANCE = new ParentTooYoung(); + + /** + * Statically initializes the query specification after the field {@link #INSTANCE} is assigned. + * This initialization order is required to support indirect recursion. + * + *

The static initializer is defined using a helper field to work around limitations of the code generator. + * + */ + private static final Object STATIC_INITIALIZER = ensureInitialized(); + + public static Object ensureInitialized() { + INSTANCE.ensureInitializedInternal(); + return null; + } + } + + private static class GeneratedPQuery extends BaseGeneratedEMFPQuery { + private static final ParentTooYoung.GeneratedPQuery INSTANCE = new GeneratedPQuery(); + + private final PParameter parameter_m = new PParameter("m", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT); + + private final PParameter parameter_p = new PParameter("p", "familytree.Member", new EClassTransitiveInstancesKey((EClass)getClassifierLiteralSafe("http://www.example.org/familytree", "Member")), PParameterDirection.INOUT); + + private final List parameters = Arrays.asList(parameter_m, parameter_p); + + private GeneratedPQuery() { + super(PVisibility.PUBLIC); + } + + @Override + public String getFullyQualifiedName() { + return "queries.parentTooYoung"; + } + + @Override + public List getParameterNames() { + return Arrays.asList("m","p"); + } + + @Override + public List getParameters() { + return parameters; + } + + @Override + public Set doGetContainedBodies() { + setEvaluationHints(new QueryEvaluationHint(null, QueryEvaluationHint.BackendRequirement.UNSPECIFIED)); + Set bodies = new LinkedHashSet<>(); + { + PBody body = new PBody(this); + PVariable var_m = body.getOrCreateVariableByName("m"); + PVariable var_p = body.getOrCreateVariableByName("p"); + PVariable var___0_ = body.getOrCreateVariableByName("_<0>"); + PVariable var_mAge = body.getOrCreateVariableByName("mAge"); + PVariable var_pAge = body.getOrCreateVariableByName("pAge"); + new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + body.setSymbolicParameters(Arrays.asList( + new ExportedParameter(body, var_m, parameter_m), + new ExportedParameter(body, var_p, parameter_p) + )); + // FamilyTree.members(_, m) + new TypeConstraint(body, Tuples.flatTupleOf(var___0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "FamilyTree"))); + PVariable var__virtual_0_ = body.getOrCreateVariableByName(".virtual{0}"); + new TypeConstraint(body, Tuples.flatTupleOf(var___0_, var__virtual_0_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "FamilyTree", "members"))); + new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_0_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + new Equality(body, var__virtual_0_, var_m); + // Member.parents(m, p) + new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + PVariable var__virtual_1_ = body.getOrCreateVariableByName(".virtual{1}"); + new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_1_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "parents"))); + new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_1_), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + new Equality(body, var__virtual_1_, var_p); + // Member.age(m, mAge) + new TypeConstraint(body, Tuples.flatTupleOf(var_m), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + PVariable var__virtual_2_ = body.getOrCreateVariableByName(".virtual{2}"); + new TypeConstraint(body, Tuples.flatTupleOf(var_m, var__virtual_2_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age"))); + new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_2_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt"))); + new Equality(body, var__virtual_2_, var_mAge); + // Member.age(p, pAge) + new TypeConstraint(body, Tuples.flatTupleOf(var_p), new EClassTransitiveInstancesKey((EClass)getClassifierLiteral("http://www.example.org/familytree", "Member"))); + PVariable var__virtual_3_ = body.getOrCreateVariableByName(".virtual{3}"); + new TypeConstraint(body, Tuples.flatTupleOf(var_p, var__virtual_3_), new EStructuralFeatureInstancesKey(getFeatureLiteral("http://www.example.org/familytree", "Member", "age"))); + new TypeConstraint(body, Tuples.flatTupleOf(var__virtual_3_), new EDataTypeInSlotsKey((EDataType)getClassifierLiteral("http://www.eclipse.org/emf/2002/Ecore", "EInt"))); + new Equality(body, var__virtual_3_, var_pAge); + // check (mAge <= (pAge + 12)) + new ExpressionEvaluation(body, new IExpressionEvaluator() { + + @Override + public String getShortDescription() { + return "Expression evaluation from pattern parentTooYoung"; + } + + @Override + public Iterable getInputParameterNames() { + return Arrays.asList("mAge", "pAge");} + + @Override + public Object evaluateExpression(IValueProvider provider) throws Exception { + Integer mAge = (Integer) provider.getValue("mAge"); + Integer pAge = (Integer) provider.getValue("pAge"); + return evaluateExpression_1_1(mAge, pAge); + } + }, null); + bodies.add(body); + } + { + PAnnotation annotation = new PAnnotation("Constraint"); + annotation.addAttribute("message", "parentTooYoung"); + annotation.addAttribute("severity", "error"); + annotation.addAttribute("key", Arrays.asList(new Object[] { + new ParameterReference("m"), + new ParameterReference("p") + })); + addAnnotation(annotation); + } + return bodies; + } + } + + private static boolean evaluateExpression_1_1(final Integer mAge, final Integer pAge) { + return ((mAge).intValue() <= ((pAge).intValue() + 12)); + } +} diff --git a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src-gen/queries/TwoMembersHaveNoParent.java new file mode 100644 index 00000000..58ad57a6 --- /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.familyTree.run/src/queries/familyTreeConstraints.vql b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src/queries/familyTreeConstraints.vql index 1b9b6659..a204443a 100644 --- a/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src/queries/familyTreeConstraints.vql +++ b/Tests/MODELS2020-CaseStudies/case.study.familyTree.run/src/queries/familyTreeConstraints.vql @@ -9,14 +9,25 @@ pattern memberIsItsOwnParent(m: Member) = { m == p; } -//@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="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)); +} -- cgit v1.2.3-70-g09d2