1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
|
package hu.bme.mit.inf.dslreasoner.domains.transima.fam
import epackage "http://www.inf.mit.bme.hu/viatrasolver/example/fam"
@Constraint(message="terminatorAndInformation", severity="error", key={T})
pattern terminatorAndInformation(T : FAMTerminator, I : InformationLink) = {
FunctionalOutput.outgoingLinks(Out,I);
FunctionalOutput.terminator(Out,T);
} or {
InformationLink.to(I,In);
FunctionalInput.terminator(In,T);
}
@QueryBasedFeature
pattern type(This : Function, Target : FunctionType) = {
find rootElements(_Model, This);
Target == FunctionType::Root;
} or {
neg find parent(_Child, This);
neg find rootElements(_Model, This);
Target == FunctionType::Leaf;
} or {
find parent(This, _Par);
find parent(_Child, This);
Target == FunctionType::Intermediate;
}
pattern rootElements(Model: FunctionalArchitectureModel, Root : Function) = {
FunctionalArchitectureModel.rootElements(Model, Root);
}
pattern parent(Func : Function, Par : Function) = {
Function.parent(Func, Par);
}
@QueryBasedFeature
pattern model(This:FunctionalElement, Target: FunctionalArchitectureModel) {
FunctionalElement(This);
FunctionalArchitectureModel(Target);
}
pattern hasRoot(F : Function) {
find rootElements(_Model, F);
}
pattern hasInt(F : Function) {
neg find parent(_Child, F);
neg find rootElements(_Model, F);
}
pattern hasLeaf(F : Function) {
find parent(F, _Par);
find parent(_Child, F);
}
/*
@Constraint(message="noRoot", severity="error", key={fam})
pattern noRoot(fam: FunctionalArchitectureModel) {
FunctionalArchitectureModel(fam);
neg find hasRoot(_);
}
@Constraint(message="noIntermediate", severity="error", key={fam})
pattern noInt(fam: FunctionalArchitectureModel) {
FunctionalArchitectureModel(fam);
neg find hasInt(_);
}
@Constraint(message="noLeaf", severity="error", key={fam})
pattern noLeaf(fam: FunctionalArchitectureModel) {
FunctionalArchitectureModel(fam);
neg find hasLeaf(_);
}*/
/*
@QueryBasedFeature
pattern model(This : FunctionalElement, Target : FunctionalArchitectureModel) = {
find parent+(This, Parent);
find rootElements(Target, Parent);
} or {
find rootElements(Target, This);
}
pattern interfaceData(FI : FunctionalInterface, FD : FunctionalData) = {
FunctionalInterface.data(FI, FD);
}
@QueryBasedFeature
pattern inputs(This : FunctionalInterface, Target : FunctionalInput) = {
find interfaceData(This, Target);
}
@QueryBasedFeature
pattern outputs(This : FunctionalInterface, Target : FunctionalOutput) = {
find interfaceData(This, Target);
}
@QueryBasedFeature
pattern outgoingLinks(This : FunctionalElement, Target : InformationLink) = {
FunctionalElement.interface.outputs(This, Output);
InformationLink.from(Target, Output);
}
@QueryBasedFeature
pattern incomingLinks(This : FunctionalElement, Target : InformationLink) = {
FunctionalElement.interface.inputs(This, Input);
InformationLink.to(Target, Input);
}
@QueryBasedFeature
pattern connects(This : FunctionalElement, Target : FunctionalElement) = {
FunctionalElement.outgoingLinks(This,Link);
FunctionalElement.incomingLinks(Target,Link);
}*/
/*pattern frequency(a: Function, b : EInt) {
Function.minimumFrequency(a,b);
}*/
|
