From 8e461ef60f59a2cb57ddca31a0b785c1b046e63a Mon Sep 17 00:00:00 2001 From: ArenBabikian Date: Mon, 3 Feb 2020 15:20:02 -0500 Subject: VAMPIRE: last commit --- .../configs/fam.vsconfig | 6 +- .../outputs/fam/debug/errors.txt | 107 +- .../fam/debug/generated3valued.vql_deactivated | 17611 +++++++++++++++++++ .../outputs/fam/debug/generation.logicproblem | 69 +- .../outputs/fam/debug/init.partialmodel | 7 +- .../outputs/fam/log.txt | 2 +- .../outputs/fam/models/1.gml | 3429 ++++ .../outputs/fam/models/1.png | Bin 73113 -> 85126 bytes .../outputs/fam/models/1.xmi | 22 +- .../outputs/fam/models/2.gml | 2506 +++ .../outputs/fam/models/2.png | Bin 75459 -> 83599 bytes .../outputs/fam/models/2.xmi | 21 +- .../outputs/fam/models/3.gml | 2469 +++ .../outputs/fam/models/3.png | Bin 75681 -> 65027 bytes .../outputs/fam/models/3.xmi | 21 +- .../outputs/fam/models/4.gml | 2505 +++ .../outputs/fam/models/4.png | Bin 88715 -> 65007 bytes .../outputs/fam/models/4.xmi | 21 +- .../outputs/fam/models/5.gml | 2505 +++ .../outputs/fam/models/5.png | Bin 88028 -> 64375 bytes .../outputs/fam/models/5.xmi | 22 +- .../outputs/fam/statistics.csv | 6 + 22 files changed, 31196 insertions(+), 133 deletions(-) (limited to 'Tests/ca.mcgill.ecse.dslreasoner.standalone.test') diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/configs/fam.vsconfig b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/configs/fam.vsconfig index e56cf30c..ca40f487 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/configs/fam.vsconfig +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/configs/fam.vsconfig @@ -1,10 +1,10 @@ import epackage "FamMetamodel" -import viatra "ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.FamPatterns" +//import viatra "ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.FamPatterns" generate { metamodel = { package fam } - constraints = { package ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries} - partial-model = { "platform:/resource/ca.mcgill.ecse.dslreasoner.standalone.test/instanceModels/famInstance.xmi"} +// constraints = { package ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries} +// partial-model = { "platform:/resource/ca.mcgill.ecse.dslreasoner.standalone.test/instanceModels/famInstance.xmi"} solver = ViatraSolver scope = { #node = 10 diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/errors.txt b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/errors.txt index 28b10066..d66c8df1 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/errors.txt +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/errors.txt @@ -445,4 +445,109 @@ Error occured (UnsupportedOperationException): Can not transform pattern "ca.mcg hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.execute(ScriptExecutor.java:339) hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor.executeScript(ScriptExecutor.java:111) hu.bme.mit.inf.dslreasoner.application.execution.ScriptExecutor$1.run(ScriptExecutor.java:73) - org.eclipse.core.internal.jobs.Worker.run(Worker.java:56) \ No newline at end of file + org.eclipse.core.internal.jobs.Worker.run(Worker.java:56)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60)Error occured (NoSuchElementException): Cannot find entry with FQN ca.mcgill.ecse.dslreasoner.standalone.test.fam.queries.model + org.eclipse.viatra.query.runtime.registry.impl.GlobalRegistryView.getEntry(GlobalRegistryView.java:56) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.findQuerySpecification(QueryBasedFeatureSettingDelegateFactory.java:152) + org.eclipse.viatra.addon.querybasedfeatures.runtime.QueryBasedFeatureSettingDelegateFactory.createSettingDelegate(QueryBasedFeatureSettingDelegateFactory.java:113) + org.eclipse.emf.ecore.impl.EStructuralFeatureImpl.getSettingDelegate(EStructuralFeatureImpl.java:854) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionalElementImpl.(FunctionalElementImpl.java:57) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.FunctionImpl.(FunctionImpl.java:64) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.createFunction(famFactoryImpl.java:125) + ca.mcgill.ecse.dslreasoner.standalone.test.fam.impl.famFactoryImpl.create(famFactoryImpl.java:68) + hu.bme.mit.inf.dslreasoner.logic2ecore.Logic2Ecore.transformInterpretation(Logic2Ecore.java:75) + hu.bme.mit.inf.dslreasoner.application.execution.GenerationTaskExecutor.executeGenerationTask(GenerationTaskExecutor.java:359) + 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.ScriptExecutor$1.run(ScriptExecutor.java:73) + org.eclipse.core.internal.jobs.Worker.run(Worker.java:60) \ No newline at end of file diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generated3valued.vql_deactivated b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generated3valued.vql_deactivated index b3223685..4ca1b4b0 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generated3valued.vql_deactivated +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generated3valued.vql_deactivated @@ -55028,3 +55028,17614 @@ pattern refineRelation_type_attribute_Function( find mayInRelationtype_attribute_Function(problem,interpretation,from,to); neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); } +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class_UndefinedPart( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class UndefinedPart"); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries terminatorAndInformation +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mustInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + var_virtual0 == var_I; + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + find mustInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + var_virtual0 == var_In; + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mayInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mayInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_I); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + find mayEquivalent(problem, interpretation, var_virtual1, var_T); +}or{ + find interpretation(problem,interpretation); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + find mayInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mayInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_In); + find mayInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + find mayEquivalent(problem, interpretation, var_virtual1, var_T); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mustInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + var_virtual0 == var_I; + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + find mustInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + var_virtual0 == var_In; + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +} +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries rootElements +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mustInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Root; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mayInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mayInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_Root); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mustInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Root; +} +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries parent +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mustInstanceOfFunction_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Par; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFunction_class(problem,interpretation,var_Func); + find mayInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mayInstanceOfFunction_class(problem,interpretation,var_Func); + find mayInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mayInstanceOfFunction_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_Par); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mustInstanceOfFunction_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Par; +} + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// +pattern invalidatedBy_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem,interpretation,var_T,var_I); +} + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// +pattern unfinishedBy_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem,interpretation,var_T,var_I); +} + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalArchitectureModel_class_UndefinedPart( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class UndefinedPart"); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class DefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class DefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class UndefinedPart"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class UndefinedPart". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class_UndefinedPart(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries terminatorAndInformation +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mustInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + var_virtual0 == var_I; + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + find mustInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + var_virtual0 == var_In; + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mayInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mayInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_I); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + find mayEquivalent(problem, interpretation, var_virtual1, var_T); +}or{ + find interpretation(problem,interpretation); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mayInstanceOfInformationLink_class(problem,interpretation,var_I); + find mayInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mayInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_In); + find mayInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mayInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + find mayEquivalent(problem, interpretation, var_virtual1, var_T); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation( + problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,var_Out,var_virtual0); + find mustInstanceOfInformationLink_class(problem,interpretation,var_virtual0); + var_virtual0 == var_I; + find mustInstanceOfFunctionalOutput_class(problem,interpretation,var_Out); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_Out,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_T); + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + // T is exported + // I is exported + find mustInstanceOfInformationLink_class(problem,interpretation,var_I); + find mustInRelationto_reference_InformationLink(problem,interpretation,var_I,var_virtual0); + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_virtual0); + var_virtual0 == var_In; + find mustInstanceOfFunctionalInput_class(problem,interpretation,var_In); + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,var_In,var_virtual1); + find mustInstanceOfFAMTerminator_class(problem,interpretation,var_virtual1); + var_virtual1 == var_T; +} +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries rootElements +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mustInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Root; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mayInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mayInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_Root); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_rootElements( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Model, var_Root) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInstanceOfFunction_class(problem,interpretation,var_Root); + // Model is exported + // Root is exported + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,var_Model); + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,var_Model,var_virtual0); + find mustInstanceOfFunctionalElement_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Root; +} +// Must, May and Current queries for pattern ca mcgill ecse dslreasoner standalone test fam queries parent +private pattern mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mustInstanceOfFunction_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Par; +} +private pattern mayInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mayInstanceOfFunction_class(problem,interpretation,var_Func); + find mayInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mayInstanceOfFunction_class(problem,interpretation,var_Func); + find mayInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mayInstanceOfFunction_class(problem,interpretation,var_virtual0); + find mayEquivalent(problem, interpretation, var_virtual0, var_Par); +} +private pattern currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_parent( + problem:LogicProblem, interpretation:PartialInterpretation, + var_Func, var_Par) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInstanceOfFunction_class(problem,interpretation,var_Par); + // Func is exported + // Par is exported + find mustInstanceOfFunction_class(problem,interpretation,var_Func); + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,var_Func,var_virtual0); + find mustInstanceOfFunction_class(problem,interpretation,var_virtual0); + var_virtual0 == var_Par; +} + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// +pattern invalidatedBy_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find mustInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem,interpretation,var_T,var_I); +} + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// +pattern unfinishedBy_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem:LogicProblem, interpretation:PartialInterpretation, + var_T, var_I) +{ + find currentInRelation_pattern_ca_mcgill_ecse_dslreasoner_standalone_test_fam_queries_terminatorAndInformation(problem,interpretation,var_T,var_I); +} + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_DefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class_UndefinedPart( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class UndefinedPart"); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class_UndefinedPart(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class_UndefinedPart(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} +import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem" +import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language" + +////////// +// 0. Util +////////// +private pattern interpretation(problem:LogicProblem, interpretation:PartialInterpretation) { + PartialInterpretation.problem(interpretation,problem); +} + +///////////////////////// +// 0.1 Existence +///////////////////////// +private pattern mustExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find interpretation(problem,interpretation); + LogicProblem.elements(problem,element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); +} + +private pattern mayExist(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + find mustExist(problem,interpretation,element); +} or { + find interpretation(problem,interpretation); + neg find elementCloseWorld(element); + PartialInterpretation.openWorldElements(interpretation,element); +} + +private pattern elementCloseWorld(element:DefinedElement) { + PartialInterpretation.openWorldElements(i,element); + PartialInterpretation.maxNewElements(i,0); +} or { + Scope.targetTypeInterpretation(scope,interpretation); + PartialTypeInterpratation.elements(interpretation,element); + Scope.maxNewElements(scope,0); +} + +//////////////////////// +// 0.2 Equivalence +//////////////////////// +pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) { + find mayExist(problem,interpretation,a); + find mayExist(problem,interpretation,b); + a == b; +} + +//////////////////////// +// 0.3 Required Patterns by TypeIndexer +//////////////////////// +private pattern typeInterpretation(problem:LogicProblem, interpretation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialComplexTypeInterpretation) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); +} + +private pattern directInstanceOf(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, type:Type) { + find interpretation(problem,interpretation); + LogicProblem.types(problem,type); + TypeDefinition.elements(type,element); +} or { + find interpretation(problem,interpretation); + find typeInterpretation(problem,interpretation,type,typeInterpretation); + PartialComplexTypeInterpretation.elements(typeInterpretation,element); +} + +private pattern isPrimitive(element: PrimitiveElement) { + PrimitiveElement(element); +} + +////////// +// 1. Problem-Specific Base Indexers +////////// +// 1.1 Type Indexers +////////// +// 1.1.1 primitive Type Indexers +////////// + +////////// +// 1.1.2 domain-specific Type Indexers +////////// +/** + * An element must be an instance of type "FunctionalElement class". + */ +private pattern mustInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalElement class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalElement class"); +} + +/** + * An element may be an instance of type "FunctionalElement class". + */ +private pattern mayInstanceOfFunctionalElement_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalElement_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalElement_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mustInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalArchitectureModel class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalArchitectureModel class"); +} + +/** + * An element may be an instance of type "FunctionalArchitectureModel class". + */ +private pattern mayInstanceOfFunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalArchitectureModel_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); } +/** + * An element must be an instance of type "Function class". + */ +private pattern mustInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"Function class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunction_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"Function class"); +} + +/** + * An element may be an instance of type "Function class". + */ +private pattern mayInstanceOfFunction_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunction_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunction_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FAMTerminator class". + */ +private pattern mustInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FAMTerminator class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FAMTerminator class"); +} + +/** + * An element may be an instance of type "FAMTerminator class". + */ +private pattern mayInstanceOfFAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFAMTerminator_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFAMTerminator_class(problem,interpretation,element); } +/** + * An element must be an instance of type "InformationLink class". + */ +private pattern mustInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"InformationLink class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"InformationLink class"); +} + +/** + * An element may be an instance of type "InformationLink class". + */ +private pattern mayInstanceOfInformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewInformationLink_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfInformationLink_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInterface class". + */ +private pattern mustInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInterface class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInterface class"); +} + +/** + * An element may be an instance of type "FunctionalInterface class". + */ +private pattern mayInstanceOfFunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInterface_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalInput class". + */ +private pattern mustInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalInput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalInput class"); +} + +/** + * An element may be an instance of type "FunctionalInput class". + */ +private pattern mayInstanceOfFunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalInput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalInput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalOutput class". + */ +private pattern mustInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalOutput class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalOutput class"); +} + +/** + * An element may be an instance of type "FunctionalOutput class". + */ +private pattern mayInstanceOfFunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalOutput_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionalData class". + */ +private pattern mustInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionalData class"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionalData class"); +} + +/** + * An element may be an instance of type "FunctionalData class". + */ +private pattern mayInstanceOfFunctionalData_class(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or { + find interpretation(problem,interpretation); + PartialInterpretation.openWorldElements(interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find scopeDisallowsNewFunctionalData_class(problem, interpretation); + neg find isPrimitive(element); +} or +{ find mustInstanceOfFunctionalData_class(problem,interpretation,element); } +/** + * An element must be an instance of type "FunctionType enum". + */ +private pattern mustInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) { + Type.name(type,"FunctionType enum"); + find directInstanceOf(problem,interpretation,element,type); +} +private pattern scopeDisallowsNewFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation) { + find interpretation(problem,interpretation); + PartialInterpretation.scopes(interpretation,scope); + Scope.targetTypeInterpretation(scope,typeInterpretation); + Scope.maxNewElements(scope,0); + PartialComplexTypeInterpretation.interpretationOf(typeInterpretation,type); + Type.name(type,"FunctionType enum"); +} + +/** + * An element may be an instance of type "FunctionType enum". + */ +private pattern mayInstanceOfFunctionType_enum(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) +{ find mustInstanceOfFunctionType_enum(problem,interpretation,element); } + +////////// +// 1.2 Relation Declaration Indexers +////////// +/** + * Matcher for detecting tuples t where []interface reference FunctionalElement(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalElement(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []model reference FunctionalElement(source,target) + */ +private pattern mustInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>model reference FunctionalElement(source,target) + */ +private pattern mayInRelationmodel_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []parent reference FunctionalElement(source,target) + */ +private pattern mustInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"parent reference FunctionalElement"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>parent reference FunctionalElement(source,target) + */ +private pattern mayInRelationparent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalElement_class(problem,interpretation,source); + find mayInstanceOfFunction_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationparent_reference_FunctionalElement(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mustInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"rootElements reference FunctionalArchitectureModel"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>rootElements reference FunctionalArchitectureModel(source,target) + */ +private pattern mayInRelationrootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []subElements reference Function(source,target) + */ +private pattern mustInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"subElements reference Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>subElements reference Function(source,target) + */ +private pattern mayInRelationsubElements_reference_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationparent_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FAMTerminator(source,target) + */ +private pattern mustInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FAMTerminator"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FAMTerminator(source,target) + */ +private pattern mayInRelationdata_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFAMTerminator_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FAMTerminator(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []from reference InformationLink(source,target) + */ +private pattern mustInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"from reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>from reference InformationLink(source,target) + */ +private pattern mayInRelationfrom_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationfrom_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []to reference InformationLink(source,target) + */ +private pattern mustInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>to reference InformationLink(source,target) + */ +private pattern mayInRelationto_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfInformationLink_class(problem,interpretation,source); + find mayInstanceOfFunctionalInput_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationto_reference_InformationLink(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []data reference FunctionalInterface(source,target) + */ +private pattern mustInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"data reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>data reference FunctionalInterface(source,target) + */ +private pattern mayInRelationdata_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalData_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []element reference FunctionalInterface(source,target) + */ +private pattern mustInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"element reference FunctionalInterface"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>element reference FunctionalInterface(source,target) + */ +private pattern mayInRelationelement_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInterface_class(problem,interpretation,source); + find mayInstanceOfFunctionalElement_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationelement_reference_FunctionalInterface(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mustInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>IncomingLinks reference FunctionalInput(source,target) + */ +private pattern mayInRelationIncomingLinks_reference_FunctionalInput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalInput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); +} or { + find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mustInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"outgoingLinks reference FunctionalOutput"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>outgoingLinks reference FunctionalOutput(source,target) + */ +private pattern mayInRelationoutgoingLinks_reference_FunctionalOutput( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalOutput_class(problem,interpretation,source); + find mayInstanceOfInformationLink_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationfrom_reference_InformationLink(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []terminator reference FunctionalData(source,target) + */ +private pattern mustInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"terminator reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>terminator reference FunctionalData(source,target) + */ +private pattern mayInRelationterminator_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFAMTerminator_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // There are "numberOfExistingReferences" currently existing instances of the reference to the target, + // the upper bound of the opposite reference multiplicity should be considered. + numberOfExistingOppositeReferences == count find mustInRelationdata_reference_FAMTerminator(problem,interpretation,target,_); + check(numberOfExistingOppositeReferences < 1); + // The reference is containment, then a new reference cannot be create if: + // 1. Multiple parents + neg find mustContains4(problem,interpretation,_,target); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []interface reference FunctionalData(source,target) + */ +private pattern mustInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"interface reference FunctionalData"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>interface reference FunctionalData(source,target) + */ +private pattern mayInRelationinterface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunctionalData_class(problem,interpretation,source); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); + // The eOpposite of the reference is containment, then a referene cannot be created if + // 1. Multiple parents + neg find mustContains4(problem,interpretation,source,_); + // 2. Circle in the containment hierarchy + neg find mustTransitiveContains(source,target); +} or { + find mustInRelationinterface_reference_FunctionalData(problem,interpretation,source,target); +} +/** + * Matcher for detecting tuples t where []type attribute Function(source,target) + */ +private pattern mustInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + PartialRelationInterpretation.relationlinks(relationIterpretation,link); + BinaryElementRelationLink.param1(link,source); + BinaryElementRelationLink.param2(link,target); +} +/** + * Matcher for detecting tuples t where <>type attribute Function(source,target) + */ +private pattern mayInRelationtype_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target:DefinedElement) +{ + find interpretation(problem,interpretation); + // The two endpoint of the link have to exist + find mayExist(problem, interpretation, source); + find mayExist(problem, interpretation, target); + // Type consistency + find mayInstanceOfFunction_class(problem,interpretation,source); + find mayInstanceOfFunctionType_enum(problem,interpretation,target); + // There are "numberOfExistingReferences" currently existing instances of the reference from the source, + // the upper bound of the multiplicity should be considered. + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,source,_); + check(numberOfExistingReferences < 1); +} or { + find mustInRelationtype_attribute_Function(problem,interpretation,source,target); +} + +////////// +// 1.3 Relation Definition Indexers +////////// + +////////// +// 1.4 Containment Indexer +////////// +private pattern mustContains2(source: DefinedElement, target: DefinedElement) { + find mustContains4(_,_,source,target); +} + +private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation, + source: DefinedElement, target: DefinedElement) + { find mustInRelationinterface_reference_FunctionalElement(problem,interpretation,source,target); }or + + { find mustInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,source,target); }or + + { find mustInRelationsubElements_reference_Function(problem,interpretation,source,target); }or + + { find mustInRelationdata_reference_FunctionalInterface(problem,interpretation,source,target); }or + + { find mustInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,source,target); }or + + { find mustInRelationterminator_reference_FunctionalData(problem,interpretation,source,target); } + +private pattern mustTransitiveContains(source,target) { + find mustContains2+(source,target); +} + +////////// +// 2. Invalidation Indexers +////////// +// 2.1 Invalidated by WF Queries +////////// + +////////// +// 3. Unfinishedness Indexers +////////// +// 3.1 Unfinishedness Measured by Multiplicity +////////// +pattern unfinishedLowerMultiplicity_model_reference_FunctionalElement(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_to_reference_InformationLink(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"to reference InformationLink"); + find mustInstanceOfInformationLink_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationto_reference_InformationLink(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} +pattern unfinishedLowerMultiplicity_type_attribute_Function(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) { + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustInstanceOfFunction_class(problem,interpretation,object); + numberOfExistingReferences == count find mustInRelationtype_attribute_Function(problem,interpretation,object,_); + check(numberOfExistingReferences < 1); + missingMultiplicity == eval(1-numberOfExistingReferences); +} + +////////// +// 3.2 Unfinishedness Measured by WF Queries +////////// + +////////// +// 4. Refinement Indexers +////////// +// 4.1 Object constructors +////////// +private pattern hasElementInContainment(problem:LogicProblem, interpretation:PartialInterpretation) +{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFAMTerminator_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunction_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfInformationLink_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalElement_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +}or{ + find interpretation(problem,interpretation); + find mustInstanceOfFunctionalData_class(problem,interpretation,root); + find mustExist(problem, interpretation, root); +} +pattern createObject_FunctionalInterface_class_by_interface_reference_FunctionalElement_with_element_reference_FunctionalInterface( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"interface reference FunctionalElement"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"element reference FunctionalInterface"); + find mustInstanceOfFunctionalElement_class(problem,interpretation,container); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayInRelationinterface_reference_FunctionalElement(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInterface_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInterface class"); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_rootElements_reference_FunctionalArchitectureModel( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"rootElements reference FunctionalArchitectureModel"); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationrootElements_reference_FunctionalArchitectureModel(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class_by_subElements_reference_Function_with_parent_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"subElements reference Function"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"parent reference FunctionalElement"); + find mustInstanceOfFunction_class(problem,interpretation,container); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayInRelationsubElements_reference_Function(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_Function_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"Function class"); + find mayInstanceOfFunction_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalOutput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalOutput class"); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class_by_terminator_reference_FunctionalData_with_data_reference_FAMTerminator( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"terminator reference FunctionalData"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"data reference FAMTerminator"); + find mustInstanceOfFunctionalData_class(problem,interpretation,container); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayInRelationterminator_reference_FunctionalData(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FAMTerminator_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FAMTerminator class"); + find mayInstanceOfFAMTerminator_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class_by_outgoingLinks_reference_FunctionalOutput_with_from_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"outgoingLinks reference FunctionalOutput"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"from reference InformationLink"); + find mustInstanceOfFunctionalOutput_class(problem,interpretation,container); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayInRelationoutgoingLinks_reference_FunctionalOutput(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_InformationLink_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"InformationLink class"); + find mayInstanceOfInformationLink_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class_by_data_reference_FunctionalInterface_with_interface_reference_FunctionalData( + problem:LogicProblem, interpretation:PartialInterpretation, + relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialComplexTypeInterpretation, + container:DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation); + PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"data reference FunctionalInterface"); + PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation); + PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"interface reference FunctionalData"); + find mustInstanceOfFunctionalInterface_class(problem,interpretation,container); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayInRelationdata_reference_FunctionalInterface(problem,interpretation,container,newObject); + find mustExist(problem, interpretation, container); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalInput_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalInput class"); + find mayInstanceOfFunctionalInput_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} +pattern createObject_FunctionalArchitectureModel_class( + problem:LogicProblem, interpretation:PartialInterpretation, + typeInterpretation:PartialComplexTypeInterpretation) +{ + find interpretation(problem,interpretation); + neg find hasElementInContainment(problem,interpretation); + PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation); + PartialComplexTypeInterpretation.interpretationOf.name(typeInterpretation,"FunctionalArchitectureModel class"); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,newObject); + find mayExist(problem, interpretation, newObject); + neg find mustExist(problem, interpretation, newObject); +} + +////////// +// 4.2 Type refinement +////////// +pattern refineTypeTo_FunctionalInterface_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_Function_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunction_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalOutput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FAMTerminator_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_InformationLink_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalInput_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalOutput_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInput_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} +pattern refineTypeTo_FunctionalArchitectureModel_class(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) { + find interpretation(problem,interpretation); + PartialInterpretation.newElements(interpretation,element); + find mayInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalInterface_class(problem,interpretation,element); + neg find mustInstanceOfFAMTerminator_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalData_class(problem,interpretation,element); + neg find mustInstanceOfInformationLink_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalElement_class(problem,interpretation,element); + neg find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,element); +} + +////////// +// 4.3 Relation refinement +////////// +pattern refineRelation_model_reference_FunctionalElement( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"model reference FunctionalElement"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalElement_class(problem,interpretation,from); + find mustInstanceOfFunctionalArchitectureModel_class(problem,interpretation,to); + find mayInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); + neg find mustInRelationmodel_reference_FunctionalElement(problem,interpretation,from,to); +} +pattern refineRelation_IncomingLinks_reference_FunctionalInput_and_to_reference_InformationLink( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, oppositeInterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"IncomingLinks reference FunctionalInput"); + PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation); + PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"to reference InformationLink"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunctionalInput_class(problem,interpretation,from); + find mustInstanceOfInformationLink_class(problem,interpretation,to); + find mayInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); + neg find mustInRelationIncomingLinks_reference_FunctionalInput(problem,interpretation,from,to); +} +pattern refineRelation_type_attribute_Function( + problem:LogicProblem, interpretation:PartialInterpretation, + relationIterpretation:PartialRelationInterpretation, + from: DefinedElement, to: DefinedElement) +{ + find interpretation(problem,interpretation); + PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation); + PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"type attribute Function"); + find mustExist(problem, interpretation, from); + find mustExist(problem, interpretation, to); + find mustInstanceOfFunction_class(problem,interpretation,from); + find mustInstanceOfFunctionType_enum(problem,interpretation,to); + find mayInRelationtype_attribute_Function(problem,interpretation,from,to); + neg find mustInRelationtype_attribute_Function(problem,interpretation,from,to); +} diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generation.logicproblem b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generation.logicproblem index 061a233a..296c3a70 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generation.logicproblem +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/generation.logicproblem @@ -1,7 +1,7 @@ - + - + @@ -10,8 +10,6 @@ - - @@ -496,22 +494,6 @@ - - - - - - - - - - - - - - - - @@ -572,53 +554,10 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + @@ -638,6 +577,4 @@ - - diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/init.partialmodel b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/init.partialmodel index 3f2640d6..55020b90 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/init.partialmodel +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/debug/init.partialmodel @@ -1,5 +1,5 @@ - + @@ -86,7 +86,6 @@ - @@ -110,9 +109,6 @@ - - - @@ -126,5 +122,4 @@ - diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/log.txt b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/log.txt index 6386e508..c7112d9d 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/log.txt +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/log.txt @@ -1 +1 @@ -Model generation startedModel generation startedModel generation startedModel generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finished \ No newline at end of file +Model generation startedModel generation startedModel generation startedModel generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finishedModel generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Model generation startedProblem is consistent, 5 models are generated!Models: [1.xmi][2.xmi][3.xmi][4.xmi][5.xmi]Visualisations: [1.gml][2.gml][3.gml][4.gml][5.gml]Visualisations: [1.png][2.png][3.png][4.png][5.png]Model generation finished \ No newline at end of file diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.gml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.gml index b0a86a61..a40633d7 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.gml +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.gml @@ -11696,3 +11696,3432 @@ graph ] ] ] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 11 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 7 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.png b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.png index 158ebb0f..a5fb7f02 100644 Binary files a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.png and b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.png differ diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.xmi b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.xmi index 3dcec4a4..ec5dbad1 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.xmi +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/1.xmi @@ -1,13 +1,11 @@ - - - - - - - - - - - - + + + + + + + + + + diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.gml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.gml index 62441d63..e581a1a4 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.gml +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.gml @@ -11699,3 +11699,2509 @@ graph ] ] ] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 7 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.png b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.png index 0222b4b1..25c578df 100644 Binary files a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.png and b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.png differ diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.xmi b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.xmi index 144e4fc5..16f82b48 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.xmi +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/2.xmi @@ -1,12 +1,11 @@ - - - - - - - - - - - + + + + + + + + + + diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.gml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.gml index e046559b..9ae40173 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.gml +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.gml @@ -11660,3 +11660,2472 @@ graph ] ] ] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 7 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.png b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.png index a551c9fc..61e37719 100644 Binary files a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.png and b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.png differ diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.xmi b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.xmi index 9e8efc63..fbbc6cb4 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.xmi +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/3.xmi @@ -1,12 +1,11 @@ - - - - - - - - - - - + + + + + + + + + + diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.gml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.gml index f41692fc..8b6731b7 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.gml +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.gml @@ -11761,3 +11761,2508 @@ graph ] ] ] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 10 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 11 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 7 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.png b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.png index c58be27f..b63f378c 100644 Binary files a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.png and b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.png differ diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.xmi b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.xmi index c5049270..950fe6a2 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.xmi +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/4.xmi @@ -1,12 +1,11 @@ - - - - - - - - - - - + + + + + + + + + + diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.gml b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.gml index 9bbf93f7..a31b5aea 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.gml +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.gml @@ -11873,3 +11873,2508 @@ graph ] ] ] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 177.10000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + InformationLink class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 7 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "from reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "to reference InformationLink" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 11 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "IncomingLinks reference FunctionalInput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "outgoingLinks reference FunctionalOutput" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 8 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 7 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] +graph +[ + node + [ + id 0 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Root literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 1 + graphics + [ + w 297.0 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Intermediate literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 2 + graphics + [ + w 226.60000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "Leaf literal FunctionType" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionType enum + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 3 + graphics + [ + w 41.800000000000004 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "true" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 4 + graphics + [ + w 50.6 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "false" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 5 + graphics + [ + w 207.9 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInterface class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 6 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 7 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 8 + graphics + [ + w 177.10000000000002 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalInput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 9 + graphics + [ + w 184.8 + h 54 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FunctionalOutput class + FunctionalData class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 10 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 11 + graphics + [ + w 161.70000000000002 + h 40 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "null" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + FAMTerminator class + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 12 + graphics + [ + w 112.2 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Integers" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 13 + graphics + [ + w 85.80000000000001 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Reals" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 14 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Strings" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + + node + [ + id 15 + graphics + [ + w 103.4 + h 26 + type "rectangle" + fill "#FFFFFF" + fill2 "#FFFFFF" + outline "#000000" + ] + LabelGraphics + [ + text "New Objects" + outline "#000000" + fill "#FFFFFF" + fontSize 16 + fontName "Monospace" + autoSizePolicy "node_width" + anchor "t" + borderDistance 0.0 + ] + LabelGraphics + [ + text " + " + fontSize 14 + fontName "Consolas" + alignment "left" + anchor "tl" + borderDistance 6 + ] + ] + edge + [ + source 7 + target 6 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 10 + target 8 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 11 + target 9 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FAMTerminator" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 6 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 8 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 5 + target 9 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "data reference FunctionalInterface" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 7 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 10 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 11 + graphics + [ + fill "#000000" + width 3 + targetArrow "standard" + ] + LabelGraphics + [ + text "terminator reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 6 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 8 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] + edge + [ + source 9 + target 5 + graphics + [ + fill "#000000" + targetArrow "standard" + ] + LabelGraphics + [ + text "interface reference FunctionalData" + fontSize 14 + fontName "Consolas" + configuration "AutoFlippingLabel" + model "six_pos" + position "thead" + ] + ] +] diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.png b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.png index a141edb0..c45fa07b 100644 Binary files a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.png and b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.png differ diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.xmi b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.xmi index c5049270..777693ab 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.xmi +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/models/5.xmi @@ -1,12 +1,12 @@ - - - - - - - - - - - + + + + + + + + + + + diff --git a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/statistics.csv b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/statistics.csv index 9f61f0e9..71fff7c5 100644 --- a/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/statistics.csv +++ b/Tests/ca.mcgill.ecse.dslreasoner.standalone.test/outputs/fam/statistics.csv @@ -26,3 +26,9 @@ Task;Run;Result;Domain to logic transformation time;Logic to solver transformati 1;1;ModelResultImpl;16;1673;1881;10488189500;142;240;275;311;375;191;21;7;0;5 Task;Run;Result;Domain to logic transformation time;Logic to solver transformation time;Solver time;Postprocessing time;_Solution0FoundAt;_Solution1FoundAt;_Solution2FoundAt;_Solution3FoundAt;_Solution4FoundAt;TransformationExecutionTime;TypeAnalysisTime;StateCoderTime;StateCoderFailCount;SolutionCopyTime 1;1;ModelResultImpl;47;1835;2309;9517642900;281;405;544;574;580;325;17;13;0;6 +Task;Run;Result;Domain to logic transformation time;Logic to solver transformation time;Solver time;Postprocessing time;_Solution0FoundAt;_Solution1FoundAt;_Solution2FoundAt;_Solution3FoundAt;_Solution4FoundAt;TransformationExecutionTime;TypeAnalysisTime;StateCoderTime;StateCoderFailCount;SolutionCopyTime +1;1;ModelResultImpl;1139;4621;3347;14457060200;924;988;1031;1071;1121;689;564;74;0;9 +Task;Run;Result;Domain to logic transformation time;Logic to solver transformation time;Solver time;Postprocessing time;_Solution0FoundAt;_Solution1FoundAt;_Solution2FoundAt;_Solution3FoundAt;_Solution4FoundAt;TransformationExecutionTime;TypeAnalysisTime;StateCoderTime;StateCoderFailCount;SolutionCopyTime +1;1;ModelResultImpl;4;2111;1772;15065362500;113;152;185;238;303;159;18;7;0;5 +Task;Run;Result;Domain to logic transformation time;Logic to solver transformation time;Solver time;Postprocessing time;_Solution0FoundAt;_Solution1FoundAt;_Solution2FoundAt;_Solution3FoundAt;_Solution4FoundAt;TransformationExecutionTime;TypeAnalysisTime;StateCoderTime;StateCoderFailCount;SolutionCopyTime +1;1;ModelResultImpl;3;1388;1240;8813500300;67;71;96;122;145;86;7;3;0;3 -- cgit v1.2.3-54-g00ecf