aboutsummaryrefslogtreecommitdiffstats
path: root/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
diff options
context:
space:
mode:
Diffstat (limited to 'Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java')
-rw-r--r--Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java1267
1 files changed, 944 insertions, 323 deletions
diff --git a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
index 1ad39fd7..5cb73796 100644
--- a/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
@@ -1,5 +1,5 @@
1/* 1/*
2 * generated by Xtext 2.18.0.M3 2 * generated by Xtext 2.21.0
3 */ 3 */
4package org.eclipse.viatra.solver.language.serializer; 4package org.eclipse.viatra.solver.language.serializer;
5 5
@@ -8,43 +8,48 @@ import java.util.Set;
8import org.eclipse.emf.ecore.EObject; 8import org.eclipse.emf.ecore.EObject;
9import org.eclipse.emf.ecore.EPackage; 9import org.eclipse.emf.ecore.EPackage;
10import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess; 10import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
11import org.eclipse.viatra.solver.language.solverLanguage.AllInstances; 11import org.eclipse.viatra.solver.language.solverLanguage.Aggregation;
12import org.eclipse.viatra.solver.language.solverLanguage.AllObjects; 12import org.eclipse.viatra.solver.language.solverLanguage.ArgumentList;
13import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation; 13import org.eclipse.viatra.solver.language.solverLanguage.Assertion;
14import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse; 14import org.eclipse.viatra.solver.language.solverLanguage.BinaryExpression;
15import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject; 15import org.eclipse.viatra.solver.language.solverLanguage.BoundedMultiplicity;
16import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol; 16import org.eclipse.viatra.solver.language.solverLanguage.BoundedScopeDefinition;
17import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue; 17import org.eclipse.viatra.solver.language.solverLanguage.Call;
18import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation; 18import org.eclipse.viatra.solver.language.solverLanguage.Case;
19import org.eclipse.viatra.solver.language.solverLanguage.Constraint; 19import org.eclipse.viatra.solver.language.solverLanguage.ClassDefinition;
20import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation; 20import org.eclipse.viatra.solver.language.solverLanguage.Comparison;
21import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation; 21import org.eclipse.viatra.solver.language.solverLanguage.Conjunction;
22import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol; 22import org.eclipse.viatra.solver.language.solverLanguage.Count;
23import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol; 23import org.eclipse.viatra.solver.language.solverLanguage.DefaultDefinition;
24import org.eclipse.viatra.solver.language.solverLanguage.False; 24import org.eclipse.viatra.solver.language.solverLanguage.Disjunction;
25import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation; 25import org.eclipse.viatra.solver.language.solverLanguage.EmptyIntervalLiteral;
26import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation; 26import org.eclipse.viatra.solver.language.solverLanguage.ExactMultiplicity;
27import org.eclipse.viatra.solver.language.solverLanguage.IntObject; 27import org.eclipse.viatra.solver.language.solverLanguage.ExactScopeDefinition;
28import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol; 28import org.eclipse.viatra.solver.language.solverLanguage.ExpressionArgument;
29import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure; 29import org.eclipse.viatra.solver.language.solverLanguage.ExternMetricDefinition;
30import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol; 30import org.eclipse.viatra.solver.language.solverLanguage.ExternPredicateDefinition;
31import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition; 31import org.eclipse.viatra.solver.language.solverLanguage.IfElse;
32import org.eclipse.viatra.solver.language.solverLanguage.NamedObject; 32import org.eclipse.viatra.solver.language.solverLanguage.InfinityLiteral;
33import org.eclipse.viatra.solver.language.solverLanguage.Negative; 33import org.eclipse.viatra.solver.language.solverLanguage.Interval;
34import org.eclipse.viatra.solver.language.solverLanguage.PatternBody; 34import org.eclipse.viatra.solver.language.solverLanguage.LogicLiteral;
35import org.eclipse.viatra.solver.language.solverLanguage.Positive; 35import org.eclipse.viatra.solver.language.solverLanguage.LowerBoundedScopeDefinition;
36import org.eclipse.viatra.solver.language.solverLanguage.Predicate; 36import org.eclipse.viatra.solver.language.solverLanguage.ManyMultiplicity;
37import org.eclipse.viatra.solver.language.solverLanguage.MemberDefinition;
38import org.eclipse.viatra.solver.language.solverLanguage.MetricDefinition;
39import org.eclipse.viatra.solver.language.solverLanguage.NamedElement;
40import org.eclipse.viatra.solver.language.solverLanguage.NumericLiteral;
41import org.eclipse.viatra.solver.language.solverLanguage.ObjectiveDefinition;
42import org.eclipse.viatra.solver.language.solverLanguage.PredicateDefinition;
37import org.eclipse.viatra.solver.language.solverLanguage.Problem; 43import org.eclipse.viatra.solver.language.solverLanguage.Problem;
38import org.eclipse.viatra.solver.language.solverLanguage.RealObject; 44import org.eclipse.viatra.solver.language.solverLanguage.Reference;
39import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
40import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
41import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage; 45import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
42import org.eclipse.viatra.solver.language.solverLanguage.StringObject; 46import org.eclipse.viatra.solver.language.solverLanguage.StarArgument;
43import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol; 47import org.eclipse.viatra.solver.language.solverLanguage.StringLiteral;
44import org.eclipse.viatra.solver.language.solverLanguage.True; 48import org.eclipse.viatra.solver.language.solverLanguage.Switch;
45import org.eclipse.viatra.solver.language.solverLanguage.Unknown; 49import org.eclipse.viatra.solver.language.solverLanguage.TypedArgument;
46import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject; 50import org.eclipse.viatra.solver.language.solverLanguage.TypedStarArgument;
47import org.eclipse.viatra.solver.language.solverLanguage.Variable; 51import org.eclipse.viatra.solver.language.solverLanguage.UnaryExpression;
52import org.eclipse.viatra.solver.language.solverLanguage.UnnamedErrorPrediateDefinition;
48import org.eclipse.xtext.Action; 53import org.eclipse.xtext.Action;
49import org.eclipse.xtext.Parameter; 54import org.eclipse.xtext.Parameter;
50import org.eclipse.xtext.ParserRule; 55import org.eclipse.xtext.ParserRule;
@@ -67,119 +72,157 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
67 Set<Parameter> parameters = context.getEnabledBooleanParameters(); 72 Set<Parameter> parameters = context.getEnabledBooleanParameters();
68 if (epackage == SolverLanguagePackage.eINSTANCE) 73 if (epackage == SolverLanguagePackage.eINSTANCE)
69 switch (semanticObject.eClass().getClassifierID()) { 74 switch (semanticObject.eClass().getClassifierID()) {
70 case SolverLanguagePackage.ALL_INSTANCES: 75 case SolverLanguagePackage.AGGREGATION:
71 sequence_AllInstances(context, (AllInstances) semanticObject); 76 sequence_Aggregation(context, (Aggregation) semanticObject);
72 return; 77 return;
73 case SolverLanguagePackage.ALL_OBJECTS: 78 case SolverLanguagePackage.ARGUMENT_LIST:
74 sequence_AllObjects(context, (AllObjects) semanticObject); 79 sequence_ArgumentList(context, (ArgumentList) semanticObject);
75 return; 80 return;
76 case SolverLanguagePackage.BASIC_INTERPRETATION: 81 case SolverLanguagePackage.ASSERTION:
77 sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject); 82 sequence_AssertionOrDefinition(context, (Assertion) semanticObject);
78 return; 83 return;
79 case SolverLanguagePackage.BOOLEAN_FALSE: 84 case SolverLanguagePackage.BINARY_EXPRESSION:
80 sequence_BooleanValue(context, (BooleanFalse) semanticObject); 85 sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(context, (BinaryExpression) semanticObject);
81 return; 86 return;
82 case SolverLanguagePackage.BOOLEAN_OBJECT: 87 case SolverLanguagePackage.BOUNDED_MULTIPLICITY:
83 sequence_BooleanObject(context, (BooleanObject) semanticObject); 88 sequence_BoundedMultiplicity(context, (BoundedMultiplicity) semanticObject);
84 return; 89 return;
85 case SolverLanguagePackage.BOOLEAN_SYMBOL: 90 case SolverLanguagePackage.BOUNDED_SCOPE_DEFINITION:
86 sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject); 91 sequence_BoundedScopeDefinition(context, (BoundedScopeDefinition) semanticObject);
87 return; 92 return;
88 case SolverLanguagePackage.BOOLEAN_TRUE: 93 case SolverLanguagePackage.CALL:
89 sequence_BooleanValue(context, (BooleanTrue) semanticObject); 94 sequence_Call(context, (Call) semanticObject);
90 return; 95 return;
91 case SolverLanguagePackage.CLASS_INTERPRETATION: 96 case SolverLanguagePackage.CASE:
92 sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject); 97 if (rule == grammarAccess.getCaseRule()) {
98 sequence_Case(context, (Case) semanticObject);
99 return;
100 }
101 else if (action == grammarAccess.getDisjunctiveExpressionAccess().getSwitchCasesAction_1_1_3()) {
102 sequence_DisjunctiveExpression_Switch_1_1_3(context, (Case) semanticObject);
103 return;
104 }
105 else break;
106 case SolverLanguagePackage.CLASS_DEFINITION:
107 sequence_ClassDefinition(context, (ClassDefinition) semanticObject);
93 return; 108 return;
94 case SolverLanguagePackage.CONSTRAINT: 109 case SolverLanguagePackage.COMPARISON:
95 sequence_Constraint(context, (Constraint) semanticObject); 110 sequence_ComparisonExpression(context, (Comparison) semanticObject);
96 return; 111 return;
97 case SolverLanguagePackage.DEFAULT_INTERPRETATION: 112 case SolverLanguagePackage.CONJUNCTION:
98 sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject); 113 sequence_ConjunctiveExpression(context, (Conjunction) semanticObject);
99 return; 114 return;
100 case SolverLanguagePackage.ENUM_INTERPRETATION: 115 case SolverLanguagePackage.COUNT:
101 sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject); 116 sequence_Count(context, (Count) semanticObject);
102 return; 117 return;
103 case SolverLanguagePackage.EQUALS_SYMBOL: 118 case SolverLanguagePackage.DEFAULT_DEFINITION:
104 sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject); 119 sequence_DefaultDefinition(context, (DefaultDefinition) semanticObject);
105 return; 120 return;
106 case SolverLanguagePackage.ERROR: 121 case SolverLanguagePackage.DISJUNCTION:
107 sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject); 122 sequence_DisjunctiveExpression(context, (Disjunction) semanticObject);
108 return; 123 return;
109 case SolverLanguagePackage.EXIST_SYMBOL: 124 case SolverLanguagePackage.EMPTY_INTERVAL_LITERAL:
110 sequence_ExistSymbol(context, (ExistSymbol) semanticObject); 125 sequence_EmptyIntervalLiteral(context, (EmptyIntervalLiteral) semanticObject);
111 return; 126 return;
112 case SolverLanguagePackage.FALSE: 127 case SolverLanguagePackage.EXACT_MULTIPLICITY:
113 sequence_TruthValue(context, (False) semanticObject); 128 sequence_ExactMultiplicity(context, (ExactMultiplicity) semanticObject);
114 return; 129 return;
115 case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION: 130 case SolverLanguagePackage.EXACT_SCOPE_DEFINITION:
116 sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject); 131 sequence_ExactScopeDefinition(context, (ExactScopeDefinition) semanticObject);
117 return; 132 return;
118 case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION: 133 case SolverLanguagePackage.EXPRESSION_ARGUMENT:
119 sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject); 134 sequence_ExpressionArgument(context, (ExpressionArgument) semanticObject);
120 return; 135 return;
121 case SolverLanguagePackage.INT_OBJECT: 136 case SolverLanguagePackage.EXTERN_METRIC_DEFINITION:
122 sequence_IntObject(context, (IntObject) semanticObject); 137 sequence_ExternMetricDefinition(context, (ExternMetricDefinition) semanticObject);
123 return; 138 return;
124 case SolverLanguagePackage.INTEGER_SYMBOL: 139 case SolverLanguagePackage.EXTERN_PREDICATE_DEFINITION:
125 sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject); 140 sequence_ExternPredicateDefinition(context, (ExternPredicateDefinition) semanticObject);
126 return; 141 return;
127 case SolverLanguagePackage.IRREFLEXIVE_CLOSURE: 142 case SolverLanguagePackage.IF_ELSE:
128 sequence_ClosureType(context, (IrreflexiveClosure) semanticObject); 143 sequence_IfElse(context, (IfElse) semanticObject);
129 return; 144 return;
130 case SolverLanguagePackage.MODEL_SYMBOL: 145 case SolverLanguagePackage.INFINITY_LITERAL:
131 sequence_ModelSymbol(context, (ModelSymbol) semanticObject); 146 sequence_InfinityLiteral(context, (InfinityLiteral) semanticObject);
132 return; 147 return;
133 case SolverLanguagePackage.MULTIPLICITY_DEFINITION: 148 case SolverLanguagePackage.INTERVAL:
134 sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject); 149 sequence_Interval(context, (Interval) semanticObject);
135 return; 150 return;
136 case SolverLanguagePackage.NAMED_OBJECT: 151 case SolverLanguagePackage.LOGIC_LITERAL:
137 sequence_NamedObject(context, (NamedObject) semanticObject); 152 sequence_LogicLiteral(context, (LogicLiteral) semanticObject);
138 return; 153 return;
139 case SolverLanguagePackage.NEGATIVE: 154 case SolverLanguagePackage.LOWER_BOUNDED_SCOPE_DEFINITION:
140 sequence_Polarity(context, (Negative) semanticObject); 155 sequence_LowerBoundedScopeDefinition(context, (LowerBoundedScopeDefinition) semanticObject);
141 return; 156 return;
142 case SolverLanguagePackage.PARAMETER: 157 case SolverLanguagePackage.MANY_MULTIPLICITY:
143 sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject); 158 sequence_ManyMultiplicity(context, (ManyMultiplicity) semanticObject);
144 return; 159 return;
145 case SolverLanguagePackage.PATTERN_BODY: 160 case SolverLanguagePackage.MEMBER_DEFINITION:
146 sequence_PatternBody(context, (PatternBody) semanticObject); 161 sequence_MemberDefinition(context, (MemberDefinition) semanticObject);
147 return; 162 return;
148 case SolverLanguagePackage.POSITIVE: 163 case SolverLanguagePackage.METRIC_DEFINITION:
149 sequence_Polarity(context, (Positive) semanticObject); 164 if (rule == grammarAccess.getAssertionOrDefinitionRule()) {
165 sequence_AssertionOrDefinition(context, (MetricDefinition) semanticObject);
166 return;
167 }
168 else if (rule == grammarAccess.getStatementRule()) {
169 sequence_AssertionOrDefinition_MetricDefinition(context, (MetricDefinition) semanticObject);
170 return;
171 }
172 else if (rule == grammarAccess.getMetricDefinitionRule()) {
173 sequence_MetricDefinition(context, (MetricDefinition) semanticObject);
174 return;
175 }
176 else break;
177 case SolverLanguagePackage.NAMED_ELEMENT:
178 sequence_NamedElement(context, (NamedElement) semanticObject);
150 return; 179 return;
151 case SolverLanguagePackage.PREDICATE: 180 case SolverLanguagePackage.NUMERIC_LITERAL:
152 sequence_Predicate(context, (Predicate) semanticObject); 181 sequence_NumericLiteral(context, (NumericLiteral) semanticObject);
153 return; 182 return;
183 case SolverLanguagePackage.OBJECTIVE_DEFINITION:
184 sequence_ObjectiveDefinition(context, (ObjectiveDefinition) semanticObject);
185 return;
186 case SolverLanguagePackage.PREDICATE_DEFINITION:
187 if (rule == grammarAccess.getAssertionOrDefinitionRule()) {
188 sequence_AssertionOrDefinition(context, (PredicateDefinition) semanticObject);
189 return;
190 }
191 else if (rule == grammarAccess.getStatementRule()) {
192 sequence_AssertionOrDefinition_PredicateDefinition(context, (PredicateDefinition) semanticObject);
193 return;
194 }
195 else if (rule == grammarAccess.getPredicateDefinitionRule()) {
196 sequence_PredicateDefinition(context, (PredicateDefinition) semanticObject);
197 return;
198 }
199 else break;
154 case SolverLanguagePackage.PROBLEM: 200 case SolverLanguagePackage.PROBLEM:
155 sequence_Problem(context, (Problem) semanticObject); 201 sequence_Problem(context, (Problem) semanticObject);
156 return; 202 return;
157 case SolverLanguagePackage.REAL_OBJECT: 203 case SolverLanguagePackage.REFERENCE:
158 sequence_RealObject(context, (RealObject) semanticObject); 204 sequence_Reference(context, (Reference) semanticObject);
159 return;
160 case SolverLanguagePackage.REAL_SYMBOL:
161 sequence_RealSymbol(context, (RealSymbol) semanticObject);
162 return; 205 return;
163 case SolverLanguagePackage.REFLEXIVE_CLOSURE: 206 case SolverLanguagePackage.STAR_ARGUMENT:
164 sequence_ClosureType(context, (ReflexiveClosure) semanticObject); 207 sequence_StarArgument(context, (StarArgument) semanticObject);
165 return; 208 return;
166 case SolverLanguagePackage.STRING_OBJECT: 209 case SolverLanguagePackage.STRING_LITERAL:
167 sequence_StringObject(context, (StringObject) semanticObject); 210 sequence_StringLiteral(context, (StringLiteral) semanticObject);
168 return; 211 return;
169 case SolverLanguagePackage.STRING_SYMBOL: 212 case SolverLanguagePackage.SWITCH:
170 sequence_StringSymbol(context, (StringSymbol) semanticObject); 213 sequence_DisjunctiveExpression(context, (Switch) semanticObject);
171 return; 214 return;
172 case SolverLanguagePackage.TRUE: 215 case SolverLanguagePackage.TYPED_ARGUMENT:
173 sequence_TruthValue(context, (True) semanticObject); 216 sequence_TypedArgument(context, (TypedArgument) semanticObject);
174 return; 217 return;
175 case SolverLanguagePackage.UNKNOWN: 218 case SolverLanguagePackage.TYPED_STAR_ARGUMENT:
176 sequence_TruthValue(context, (Unknown) semanticObject); 219 sequence_TypedStarArgument(context, (TypedStarArgument) semanticObject);
177 return; 220 return;
178 case SolverLanguagePackage.UNNAMED_OBJECT: 221 case SolverLanguagePackage.UNARY_EXPRESSION:
179 sequence_UnnamedObject(context, (UnnamedObject) semanticObject); 222 sequence_UnaryExpression(context, (UnaryExpression) semanticObject);
180 return; 223 return;
181 case SolverLanguagePackage.VARIABLE: 224 case SolverLanguagePackage.UNNAMED_ERROR_PREDIATE_DEFINITION:
182 sequence_Variable(context, (Variable) semanticObject); 225 sequence_UnnamedErrorPrediateDefinition(context, (UnnamedErrorPrediateDefinition) semanticObject);
183 return; 226 return;
184 } 227 }
185 if (errorAcceptor != null) 228 if (errorAcceptor != null)
@@ -188,574 +231,1152 @@ public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticS
188 231
189 /** 232 /**
190 * Contexts: 233 * Contexts:
191 * ComplexObject returns AllInstances 234 * AssertionOrDefinition.Assertion_1_0_0 returns BinaryExpression
192 * AllInstances returns AllInstances 235 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns BinaryExpression
236 * AssertionOrDefinition.MetricDefinition_1_2_0 returns BinaryExpression
237 * Expression returns BinaryExpression
238 * DisjunctiveExpression returns BinaryExpression
239 * DisjunctiveExpression.Disjunction_1_0_0 returns BinaryExpression
240 * DisjunctiveExpression.Case_1_1_0 returns BinaryExpression
241 * ConjunctiveExpression returns BinaryExpression
242 * ConjunctiveExpression.Conjunction_1_0 returns BinaryExpression
243 * ComparisonExpression returns BinaryExpression
244 * ComparisonExpression.Comparison_1_0 returns BinaryExpression
245 * AdditiveExpression returns BinaryExpression
246 * AdditiveExpression.BinaryExpression_1_0 returns BinaryExpression
247 * MultiplicativeExpression returns BinaryExpression
248 * MultiplicativeExpression.BinaryExpression_1_0 returns BinaryExpression
249 * ExponentialExpression returns BinaryExpression
250 * ExponentialExpression.BinaryExpression_1_0 returns BinaryExpression
251 * UnaryExpression returns BinaryExpression
252 * AggregationExpression returns BinaryExpression
253 * AtomicExpression returns BinaryExpression
193 * 254 *
194 * Constraint: 255 * Constraint:
195 * symbol=Symbol 256 * (
257 * (left=AdditiveExpression_BinaryExpression_1_0 op=AdditiveBinaryOperator right=MultiplicativeExpression) |
258 * (left=MultiplicativeExpression_BinaryExpression_1_0 op=MultiplicativeBinaryOperator right=ExponentialExpression) |
259 * (left=ExponentialExpression_BinaryExpression_1_0 op=ExponentialOp right=ExponentialExpression)
260 * )
196 */ 261 */
197 protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) { 262 protected void sequence_AdditiveExpression_ExponentialExpression_MultiplicativeExpression(ISerializationContext context, BinaryExpression semanticObject) {
263 genericSequencer.createSequence(context, semanticObject);
264 }
265
266
267 /**
268 * Contexts:
269 * AssertionOrDefinition.Assertion_1_0_0 returns Aggregation
270 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Aggregation
271 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Aggregation
272 * Expression returns Aggregation
273 * DisjunctiveExpression returns Aggregation
274 * DisjunctiveExpression.Disjunction_1_0_0 returns Aggregation
275 * DisjunctiveExpression.Case_1_1_0 returns Aggregation
276 * ConjunctiveExpression returns Aggregation
277 * ConjunctiveExpression.Conjunction_1_0 returns Aggregation
278 * ComparisonExpression returns Aggregation
279 * ComparisonExpression.Comparison_1_0 returns Aggregation
280 * AdditiveExpression returns Aggregation
281 * AdditiveExpression.BinaryExpression_1_0 returns Aggregation
282 * MultiplicativeExpression returns Aggregation
283 * MultiplicativeExpression.BinaryExpression_1_0 returns Aggregation
284 * ExponentialExpression returns Aggregation
285 * ExponentialExpression.BinaryExpression_1_0 returns Aggregation
286 * UnaryExpression returns Aggregation
287 * AggregationExpression returns Aggregation
288 * Aggregation returns Aggregation
289 * AtomicExpression returns Aggregation
290 *
291 * Constraint:
292 * (op=AggregationOp body=Expression condition=Expression)
293 */
294 protected void sequence_Aggregation(ISerializationContext context, Aggregation semanticObject) {
198 if (errorAcceptor != null) { 295 if (errorAcceptor != null) {
199 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES) 296 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP) == ValueTransient.YES)
200 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL)); 297 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__OP));
298 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY) == ValueTransient.YES)
299 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__BODY));
300 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION) == ValueTransient.YES)
301 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.AGGREGATION__CONDITION));
201 } 302 }
202 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 303 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
203 feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol()); 304 feeder.accept(grammarAccess.getAggregationAccess().getOpAggregationOpEnumRuleCall_0_0(), semanticObject.getOp());
305 feeder.accept(grammarAccess.getAggregationAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody());
306 feeder.accept(grammarAccess.getAggregationAccess().getConditionExpressionParserRuleCall_4_0(), semanticObject.getCondition());
204 feeder.finish(); 307 feeder.finish();
205 } 308 }
206 309
207 310
208 /** 311 /**
209 * Contexts: 312 * Contexts:
210 * ComplexObject returns AllObjects 313 * ArgumentList returns ArgumentList
211 * AllObjects returns AllObjects
212 * 314 *
213 * Constraint: 315 * Constraint:
214 * {AllObjects} 316 * (arguments+=Argument arguments+=Argument*)?
215 */ 317 */
216 protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) { 318 protected void sequence_ArgumentList(ISerializationContext context, ArgumentList semanticObject) {
217 genericSequencer.createSequence(context, semanticObject); 319 genericSequencer.createSequence(context, semanticObject);
218 } 320 }
219 321
220 322
221 /** 323 /**
222 * Contexts: 324 * Contexts:
223 * Statement returns BasicInterpretation 325 * Statement returns Assertion
224 * Interpretation returns BasicInterpretation 326 * AssertionOrDefinition returns Assertion
225 * BasicInterpretation returns BasicInterpretation
226 * 327 *
227 * Constraint: 328 * Constraint:
228 * (symbol=Symbol (objects+=ComplexObject objects+=ComplexObject*)? value=TruthValue) 329 * (body=AssertionOrDefinition_Assertion_1_0_0 range=Expression?)
229 */ 330 */
230 protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) { 331 protected void sequence_AssertionOrDefinition(ISerializationContext context, Assertion semanticObject) {
231 genericSequencer.createSequence(context, semanticObject); 332 genericSequencer.createSequence(context, semanticObject);
232 } 333 }
233 334
234 335
235 /** 336 /**
236 * Contexts: 337 * Contexts:
237 * ComplexObject returns BooleanObject 338 * AssertionOrDefinition returns MetricDefinition
238 * Object returns BooleanObject
239 * DataObject returns BooleanObject
240 * BooleanObject returns BooleanObject
241 * Literal returns BooleanObject
242 * 339 *
243 * Constraint: 340 * Constraint:
244 * value=BooleanValue 341 * (head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression)
245 */ 342 */
246 protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) { 343 protected void sequence_AssertionOrDefinition(ISerializationContext context, MetricDefinition semanticObject) {
247 if (errorAcceptor != null) { 344 if (errorAcceptor != null) {
248 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES) 345 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES)
249 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE)); 346 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD));
347 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES)
348 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY));
250 } 349 }
251 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 350 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
252 feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue()); 351 feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getMetricDefinitionHeadAction_1_2_0(), semanticObject.getHead());
352 feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_2_2_0(), semanticObject.getBody());
253 feeder.finish(); 353 feeder.finish();
254 } 354 }
255 355
256 356
257 /** 357 /**
258 * Contexts: 358 * Contexts:
259 * Symbol returns BooleanSymbol 359 * Statement returns MetricDefinition
260 * DataSymbol returns BooleanSymbol
261 * BooleanSymbol returns BooleanSymbol
262 * 360 *
263 * Constraint: 361 * Constraint:
264 * {BooleanSymbol} 362 * ((head=AssertionOrDefinition_MetricDefinition_1_2_0 body=Expression) | (type=MetricType head=Expression body=Expression))
265 */ 363 */
266 protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) { 364 protected void sequence_AssertionOrDefinition_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) {
267 genericSequencer.createSequence(context, semanticObject); 365 genericSequencer.createSequence(context, semanticObject);
268 } 366 }
269 367
270 368
271 /** 369 /**
272 * Contexts: 370 * Contexts:
273 * BooleanValue returns BooleanFalse 371 * AssertionOrDefinition returns PredicateDefinition
274 * 372 *
275 * Constraint: 373 * Constraint:
276 * {BooleanFalse} 374 * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression)
277 */ 375 */
278 protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) { 376 protected void sequence_AssertionOrDefinition(ISerializationContext context, PredicateDefinition semanticObject) {
279 genericSequencer.createSequence(context, semanticObject); 377 if (errorAcceptor != null) {
378 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD) == ValueTransient.YES)
379 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__HEAD));
380 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY) == ValueTransient.YES)
381 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.PREDICATE_DEFINITION__BODY));
382 }
383 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
384 feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getPredicateDefinitionHeadAction_1_1_0(), semanticObject.getHead());
385 feeder.accept(grammarAccess.getAssertionOrDefinitionAccess().getBodyExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody());
386 feeder.finish();
280 } 387 }
281 388
282 389
283 /** 390 /**
284 * Contexts: 391 * Contexts:
285 * BooleanValue returns BooleanTrue 392 * Statement returns PredicateDefinition
286 * 393 *
287 * Constraint: 394 * Constraint:
288 * {BooleanTrue} 395 * (
396 * (head=AssertionOrDefinition_PredicateDefinition_1_1_0 body=Expression) |
397 * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression)
398 * )
289 */ 399 */
290 protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) { 400 protected void sequence_AssertionOrDefinition_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) {
291 genericSequencer.createSequence(context, semanticObject); 401 genericSequencer.createSequence(context, semanticObject);
292 } 402 }
293 403
294 404
295 /** 405 /**
296 * Contexts: 406 * Contexts:
297 * Statement returns ClassInterpretation 407 * Multiplicity returns BoundedMultiplicity
298 * Interpretation returns ClassInterpretation 408 * BoundedMultiplicity returns BoundedMultiplicity
299 * CDInterpretation returns ClassInterpretation
300 * ClassInterpretation returns ClassInterpretation
301 * 409 *
302 * Constraint: 410 * Constraint:
303 * (abstract?='abstract'? symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*) 411 * (lowerBound=INT upperBound=UpperMultiplicty)
304 */ 412 */
305 protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) { 413 protected void sequence_BoundedMultiplicity(ISerializationContext context, BoundedMultiplicity semanticObject) {
306 genericSequencer.createSequence(context, semanticObject); 414 if (errorAcceptor != null) {
415 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND) == ValueTransient.YES)
416 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__LOWER_BOUND));
417 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND) == ValueTransient.YES)
418 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOUNDED_MULTIPLICITY__UPPER_BOUND));
419 }
420 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
421 feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getLowerBoundINTTerminalRuleCall_1_0(), semanticObject.getLowerBound());
422 feeder.accept(grammarAccess.getBoundedMultiplicityAccess().getUpperBoundUpperMultiplictyParserRuleCall_3_0(), semanticObject.getUpperBound());
423 feeder.finish();
307 } 424 }
308 425
309 426
310 /** 427 /**
311 * Contexts: 428 * Contexts:
312 * ClosureType returns IrreflexiveClosure 429 * Statement returns BoundedScopeDefinition
430 * ScopeDefinition returns BoundedScopeDefinition
431 * BoundedScopeDefinition returns BoundedScopeDefinition
313 * 432 *
314 * Constraint: 433 * Constraint:
315 * {IrreflexiveClosure} 434 * ((lowerBound=INT? type=[NamedElement|QualifiedName] upperBound=INT) | (upperBound=INT type=[NamedElement|QualifiedName] lowerBound=INT?))
316 */ 435 */
317 protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) { 436 protected void sequence_BoundedScopeDefinition(ISerializationContext context, BoundedScopeDefinition semanticObject) {
318 genericSequencer.createSequence(context, semanticObject); 437 genericSequencer.createSequence(context, semanticObject);
319 } 438 }
320 439
321 440
322 /** 441 /**
323 * Contexts: 442 * Contexts:
324 * ClosureType returns ReflexiveClosure 443 * AssertionOrDefinition.Assertion_1_0_0 returns Call
444 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Call
445 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Call
446 * Expression returns Call
447 * DisjunctiveExpression returns Call
448 * DisjunctiveExpression.Disjunction_1_0_0 returns Call
449 * DisjunctiveExpression.Case_1_1_0 returns Call
450 * ConjunctiveExpression returns Call
451 * ConjunctiveExpression.Conjunction_1_0 returns Call
452 * ComparisonExpression returns Call
453 * ComparisonExpression.Comparison_1_0 returns Call
454 * AdditiveExpression returns Call
455 * AdditiveExpression.BinaryExpression_1_0 returns Call
456 * MultiplicativeExpression returns Call
457 * MultiplicativeExpression.BinaryExpression_1_0 returns Call
458 * ExponentialExpression returns Call
459 * ExponentialExpression.BinaryExpression_1_0 returns Call
460 * UnaryExpression returns Call
461 * AggregationExpression returns Call
462 * AtomicExpression returns Call
463 * Call returns Call
325 * 464 *
326 * Constraint: 465 * Constraint:
327 * {ReflexiveClosure} 466 * (
467 * functor=Reference
468 * (transitiveClosure?=TRANSITIVE_CLOSURE | reflexiveTransitiveClosure?=REFLEXIVE_TRANSITIVE_CLOSURE)?
469 * argumentList=ArgumentList
470 * )
328 */ 471 */
329 protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) { 472 protected void sequence_Call(ISerializationContext context, Call semanticObject) {
330 genericSequencer.createSequence(context, semanticObject); 473 genericSequencer.createSequence(context, semanticObject);
331 } 474 }
332 475
333 476
334 /** 477 /**
335 * Contexts: 478 * Contexts:
336 * Constraint returns Constraint 479 * Case returns Case
480 *
481 * Constraint:
482 * (condition=ConjunctiveExpression body=ConjunctiveExpression)
483 */
484 protected void sequence_Case(ISerializationContext context, Case semanticObject) {
485 if (errorAcceptor != null) {
486 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES)
487 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION));
488 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES)
489 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY));
490 }
491 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
492 feeder.accept(grammarAccess.getCaseAccess().getConditionConjunctiveExpressionParserRuleCall_0_0(), semanticObject.getCondition());
493 feeder.accept(grammarAccess.getCaseAccess().getBodyConjunctiveExpressionParserRuleCall_2_0(), semanticObject.getBody());
494 feeder.finish();
495 }
496
497
498 /**
499 * Contexts:
500 * Statement returns ClassDefinition
501 * ClassDefinition returns ClassDefinition
337 * 502 *
338 * Constraint: 503 * Constraint:
339 * ((polarity=Polarity? symbol=ModelSymbol params+=Literal? params+=Literal*) | (closureType=ClosureType params+=Literal? params+=Literal*)) 504 * (
505 * abstract?='abstract'?
506 * name=ID
507 * (superclasses+=[NamedElement|QualifiedName] superclasses+=[NamedElement|QualifiedName]*)?
508 * members+=MemberDefinition*
509 * )
340 */ 510 */
341 protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) { 511 protected void sequence_ClassDefinition(ISerializationContext context, ClassDefinition semanticObject) {
342 genericSequencer.createSequence(context, semanticObject); 512 genericSequencer.createSequence(context, semanticObject);
343 } 513 }
344 514
345 515
346 /** 516 /**
347 * Contexts: 517 * Contexts:
348 * Statement returns DefaultInterpretation 518 * AssertionOrDefinition.Assertion_1_0_0 returns Comparison
349 * Interpretation returns DefaultInterpretation 519 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Comparison
350 * DefaultInterpretation returns DefaultInterpretation 520 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Comparison
521 * Expression returns Comparison
522 * DisjunctiveExpression returns Comparison
523 * DisjunctiveExpression.Disjunction_1_0_0 returns Comparison
524 * DisjunctiveExpression.Case_1_1_0 returns Comparison
525 * ConjunctiveExpression returns Comparison
526 * ConjunctiveExpression.Conjunction_1_0 returns Comparison
527 * ComparisonExpression returns Comparison
528 * ComparisonExpression.Comparison_1_0 returns Comparison
529 * AdditiveExpression returns Comparison
530 * AdditiveExpression.BinaryExpression_1_0 returns Comparison
531 * MultiplicativeExpression returns Comparison
532 * MultiplicativeExpression.BinaryExpression_1_0 returns Comparison
533 * ExponentialExpression returns Comparison
534 * ExponentialExpression.BinaryExpression_1_0 returns Comparison
535 * UnaryExpression returns Comparison
536 * AggregationExpression returns Comparison
537 * AtomicExpression returns Comparison
351 * 538 *
352 * Constraint: 539 * Constraint:
353 * interpretation=BasicInterpretation 540 * (left=ComparisonExpression_Comparison_1_0 op=ComparisonOperator right=AdditiveExpression)
354 */ 541 */
355 protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) { 542 protected void sequence_ComparisonExpression(ISerializationContext context, Comparison semanticObject) {
356 if (errorAcceptor != null) { 543 if (errorAcceptor != null) {
357 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES) 544 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT) == ValueTransient.YES)
358 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION)); 545 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__LEFT));
546 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP) == ValueTransient.YES)
547 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__OP));
548 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT) == ValueTransient.YES)
549 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COMPARISON__RIGHT));
359 } 550 }
360 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 551 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
361 feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation()); 552 feeder.accept(grammarAccess.getComparisonExpressionAccess().getComparisonLeftAction_1_0(), semanticObject.getLeft());
553 feeder.accept(grammarAccess.getComparisonExpressionAccess().getOpComparisonOperatorEnumRuleCall_1_1_0(), semanticObject.getOp());
554 feeder.accept(grammarAccess.getComparisonExpressionAccess().getRightAdditiveExpressionParserRuleCall_1_2_0(), semanticObject.getRight());
362 feeder.finish(); 555 feeder.finish();
363 } 556 }
364 557
365 558
366 /** 559 /**
367 * Contexts: 560 * Contexts:
368 * Statement returns EnumInterpretation 561 * AssertionOrDefinition.Assertion_1_0_0 returns Conjunction
369 * Interpretation returns EnumInterpretation 562 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Conjunction
370 * CDInterpretation returns EnumInterpretation 563 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Conjunction
371 * EnumInterpretation returns EnumInterpretation 564 * Expression returns Conjunction
565 * DisjunctiveExpression returns Conjunction
566 * DisjunctiveExpression.Disjunction_1_0_0 returns Conjunction
567 * DisjunctiveExpression.Case_1_1_0 returns Conjunction
568 * ConjunctiveExpression returns Conjunction
569 * ConjunctiveExpression.Conjunction_1_0 returns Conjunction
570 * ComparisonExpression returns Conjunction
571 * ComparisonExpression.Comparison_1_0 returns Conjunction
572 * AdditiveExpression returns Conjunction
573 * AdditiveExpression.BinaryExpression_1_0 returns Conjunction
574 * MultiplicativeExpression returns Conjunction
575 * MultiplicativeExpression.BinaryExpression_1_0 returns Conjunction
576 * ExponentialExpression returns Conjunction
577 * ExponentialExpression.BinaryExpression_1_0 returns Conjunction
578 * UnaryExpression returns Conjunction
579 * AggregationExpression returns Conjunction
580 * AtomicExpression returns Conjunction
372 * 581 *
373 * Constraint: 582 * Constraint:
374 * (Symbol=ModelSymbol objects+=NamedObject+) 583 * (children+=ConjunctiveExpression_Conjunction_1_0 children+=ComparisonExpression+)
375 */ 584 */
376 protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) { 585 protected void sequence_ConjunctiveExpression(ISerializationContext context, Conjunction semanticObject) {
377 genericSequencer.createSequence(context, semanticObject); 586 genericSequencer.createSequence(context, semanticObject);
378 } 587 }
379 588
380 589
381 /** 590 /**
382 * Contexts: 591 * Contexts:
383 * Symbol returns EqualsSymbol 592 * AssertionOrDefinition.Assertion_1_0_0 returns Count
384 * PartialitySymbol returns EqualsSymbol 593 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Count
385 * EqualsSymbol returns EqualsSymbol 594 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Count
595 * Expression returns Count
596 * DisjunctiveExpression returns Count
597 * DisjunctiveExpression.Disjunction_1_0_0 returns Count
598 * DisjunctiveExpression.Case_1_1_0 returns Count
599 * ConjunctiveExpression returns Count
600 * ConjunctiveExpression.Conjunction_1_0 returns Count
601 * ComparisonExpression returns Count
602 * ComparisonExpression.Comparison_1_0 returns Count
603 * AdditiveExpression returns Count
604 * AdditiveExpression.BinaryExpression_1_0 returns Count
605 * MultiplicativeExpression returns Count
606 * MultiplicativeExpression.BinaryExpression_1_0 returns Count
607 * ExponentialExpression returns Count
608 * ExponentialExpression.BinaryExpression_1_0 returns Count
609 * UnaryExpression returns Count
610 * AggregationExpression returns Count
611 * Count returns Count
612 * AtomicExpression returns Count
386 * 613 *
387 * Constraint: 614 * Constraint:
388 * {EqualsSymbol} 615 * body=Expression
389 */ 616 */
390 protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) { 617 protected void sequence_Count(ISerializationContext context, Count semanticObject) {
391 genericSequencer.createSequence(context, semanticObject); 618 if (errorAcceptor != null) {
619 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY) == ValueTransient.YES)
620 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.COUNT__BODY));
621 }
622 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
623 feeder.accept(grammarAccess.getCountAccess().getBodyExpressionParserRuleCall_2_0(), semanticObject.getBody());
624 feeder.finish();
392 } 625 }
393 626
394 627
395 /** 628 /**
396 * Contexts: 629 * Contexts:
397 * Symbol returns ExistSymbol 630 * Statement returns DefaultDefinition
398 * PartialitySymbol returns ExistSymbol 631 * DefaultDefinition returns DefaultDefinition
399 * ExistSymbol returns ExistSymbol
400 * 632 *
401 * Constraint: 633 * Constraint:
402 * {ExistSymbol} 634 * (head=Call range=Expression)
403 */ 635 */
404 protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) { 636 protected void sequence_DefaultDefinition(ISerializationContext context, DefaultDefinition semanticObject) {
405 genericSequencer.createSequence(context, semanticObject); 637 if (errorAcceptor != null) {
638 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD) == ValueTransient.YES)
639 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__HEAD));
640 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE) == ValueTransient.YES)
641 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_DEFINITION__RANGE));
642 }
643 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
644 feeder.accept(grammarAccess.getDefaultDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead());
645 feeder.accept(grammarAccess.getDefaultDefinitionAccess().getRangeExpressionParserRuleCall_3_0(), semanticObject.getRange());
646 feeder.finish();
406 } 647 }
407 648
408 649
409 /** 650 /**
410 * Contexts: 651 * Contexts:
411 * FieldRelationInterpretation returns FieldRelationInterpretation 652 * AssertionOrDefinition.Assertion_1_0_0 returns Disjunction
653 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Disjunction
654 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Disjunction
655 * Expression returns Disjunction
656 * DisjunctiveExpression returns Disjunction
657 * DisjunctiveExpression.Disjunction_1_0_0 returns Disjunction
658 * DisjunctiveExpression.Case_1_1_0 returns Disjunction
659 * ConjunctiveExpression returns Disjunction
660 * ConjunctiveExpression.Conjunction_1_0 returns Disjunction
661 * ComparisonExpression returns Disjunction
662 * ComparisonExpression.Comparison_1_0 returns Disjunction
663 * AdditiveExpression returns Disjunction
664 * AdditiveExpression.BinaryExpression_1_0 returns Disjunction
665 * MultiplicativeExpression returns Disjunction
666 * MultiplicativeExpression.BinaryExpression_1_0 returns Disjunction
667 * ExponentialExpression returns Disjunction
668 * ExponentialExpression.BinaryExpression_1_0 returns Disjunction
669 * UnaryExpression returns Disjunction
670 * AggregationExpression returns Disjunction
671 * AtomicExpression returns Disjunction
412 * 672 *
413 * Constraint: 673 * Constraint:
414 * (containment?='containment'? symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol) 674 * (children+=DisjunctiveExpression_Disjunction_1_0_0 children+=ConjunctiveExpression+)
415 */ 675 */
416 protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) { 676 protected void sequence_DisjunctiveExpression(ISerializationContext context, Disjunction semanticObject) {
417 genericSequencer.createSequence(context, semanticObject); 677 genericSequencer.createSequence(context, semanticObject);
418 } 678 }
419 679
420 680
421 /** 681 /**
422 * Contexts: 682 * Contexts:
423 * Statement returns GlobalRelationInterpretation 683 * AssertionOrDefinition.Assertion_1_0_0 returns Switch
424 * Interpretation returns GlobalRelationInterpretation 684 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Switch
425 * CDInterpretation returns GlobalRelationInterpretation 685 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Switch
426 * GlobalRelationInterpretation returns GlobalRelationInterpretation 686 * Expression returns Switch
687 * DisjunctiveExpression returns Switch
688 * DisjunctiveExpression.Disjunction_1_0_0 returns Switch
689 * DisjunctiveExpression.Case_1_1_0 returns Switch
690 * ConjunctiveExpression returns Switch
691 * ConjunctiveExpression.Conjunction_1_0 returns Switch
692 * ComparisonExpression returns Switch
693 * ComparisonExpression.Comparison_1_0 returns Switch
694 * AdditiveExpression returns Switch
695 * AdditiveExpression.BinaryExpression_1_0 returns Switch
696 * MultiplicativeExpression returns Switch
697 * MultiplicativeExpression.BinaryExpression_1_0 returns Switch
698 * ExponentialExpression returns Switch
699 * ExponentialExpression.BinaryExpression_1_0 returns Switch
700 * UnaryExpression returns Switch
701 * AggregationExpression returns Switch
702 * AtomicExpression returns Switch
427 * 703 *
428 * Constraint: 704 * Constraint:
429 * ( 705 * (cases+=DisjunctiveExpression_Switch_1_1_3 cases+=Case*)
430 * containment?='containment'?
431 * symbol=ModelSymbol
432 * sourceMultiplicity=MultiplicityDefinition?
433 * source=Symbol
434 * targetMultiplicity=MultiplicityDefinition?
435 * target=Symbol
436 * )
437 */ 706 */
438 protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) { 707 protected void sequence_DisjunctiveExpression(ISerializationContext context, Switch semanticObject) {
439 genericSequencer.createSequence(context, semanticObject); 708 genericSequencer.createSequence(context, semanticObject);
440 } 709 }
441 710
442 711
443 /** 712 /**
444 * Contexts: 713 * Contexts:
445 * ComplexObject returns IntObject 714 * DisjunctiveExpression.Switch_1_1_3 returns Case
446 * Object returns IntObject
447 * DataObject returns IntObject
448 * IntObject returns IntObject
449 * Literal returns IntObject
450 * 715 *
451 * Constraint: 716 * Constraint:
452 * value=INTLiteral 717 * (condition=DisjunctiveExpression_Case_1_1_0 body=ConjunctiveExpression)
453 */ 718 */
454 protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) { 719 protected void sequence_DisjunctiveExpression_Switch_1_1_3(ISerializationContext context, Case semanticObject) {
455 if (errorAcceptor != null) { 720 if (errorAcceptor != null) {
456 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES) 721 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION) == ValueTransient.YES)
457 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE)); 722 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__CONDITION));
723 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.CASE__BODY) == ValueTransient.YES)
724 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.CASE__BODY));
458 } 725 }
459 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 726 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
460 feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue()); 727 feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getCaseConditionAction_1_1_0(), semanticObject.getCondition());
728 feeder.accept(grammarAccess.getDisjunctiveExpressionAccess().getBodyConjunctiveExpressionParserRuleCall_1_1_2_0(), semanticObject.getBody());
461 feeder.finish(); 729 feeder.finish();
462 } 730 }
463 731
464 732
465 /** 733 /**
466 * Contexts: 734 * Contexts:
467 * Symbol returns IntegerSymbol 735 * AssertionOrDefinition.Assertion_1_0_0 returns EmptyIntervalLiteral
468 * DataSymbol returns IntegerSymbol 736 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns EmptyIntervalLiteral
469 * IntegerSymbol returns IntegerSymbol 737 * AssertionOrDefinition.MetricDefinition_1_2_0 returns EmptyIntervalLiteral
738 * Expression returns EmptyIntervalLiteral
739 * DisjunctiveExpression returns EmptyIntervalLiteral
740 * DisjunctiveExpression.Disjunction_1_0_0 returns EmptyIntervalLiteral
741 * DisjunctiveExpression.Case_1_1_0 returns EmptyIntervalLiteral
742 * ConjunctiveExpression returns EmptyIntervalLiteral
743 * ConjunctiveExpression.Conjunction_1_0 returns EmptyIntervalLiteral
744 * ComparisonExpression returns EmptyIntervalLiteral
745 * ComparisonExpression.Comparison_1_0 returns EmptyIntervalLiteral
746 * AdditiveExpression returns EmptyIntervalLiteral
747 * AdditiveExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral
748 * MultiplicativeExpression returns EmptyIntervalLiteral
749 * MultiplicativeExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral
750 * ExponentialExpression returns EmptyIntervalLiteral
751 * ExponentialExpression.BinaryExpression_1_0 returns EmptyIntervalLiteral
752 * UnaryExpression returns EmptyIntervalLiteral
753 * AggregationExpression returns EmptyIntervalLiteral
754 * AtomicExpression returns EmptyIntervalLiteral
755 * Literal returns EmptyIntervalLiteral
756 * EmptyIntervalLiteral returns EmptyIntervalLiteral
470 * 757 *
471 * Constraint: 758 * Constraint:
472 * {IntegerSymbol} 759 * {EmptyIntervalLiteral}
473 */ 760 */
474 protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) { 761 protected void sequence_EmptyIntervalLiteral(ISerializationContext context, EmptyIntervalLiteral semanticObject) {
475 genericSequencer.createSequence(context, semanticObject); 762 genericSequencer.createSequence(context, semanticObject);
476 } 763 }
477 764
478 765
479 /** 766 /**
480 * Contexts: 767 * Contexts:
481 * Symbol returns ModelSymbol 768 * Multiplicity returns ExactMultiplicity
482 * ModelSymbol returns ModelSymbol 769 * ExactMultiplicity returns ExactMultiplicity
483 * 770 *
484 * Constraint: 771 * Constraint:
485 * name=ID 772 * multiplicity=UpperMultiplicty
486 */ 773 */
487 protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) { 774 protected void sequence_ExactMultiplicity(ISerializationContext context, ExactMultiplicity semanticObject) {
488 if (errorAcceptor != null) { 775 if (errorAcceptor != null) {
489 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES) 776 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY) == ValueTransient.YES)
490 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME)); 777 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_MULTIPLICITY__MULTIPLICITY));
491 } 778 }
492 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 779 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
493 feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); 780 feeder.accept(grammarAccess.getExactMultiplicityAccess().getMultiplicityUpperMultiplictyParserRuleCall_1_0(), semanticObject.getMultiplicity());
494 feeder.finish(); 781 feeder.finish();
495 } 782 }
496 783
497 784
498 /** 785 /**
499 * Contexts: 786 * Contexts:
500 * MultiplicityDefinition returns MultiplicityDefinition 787 * Statement returns ExactScopeDefinition
788 * ScopeDefinition returns ExactScopeDefinition
789 * ExactScopeDefinition returns ExactScopeDefinition
501 * 790 *
502 * Constraint: 791 * Constraint:
503 * (lower=INT (upper=INT | unlimitedUpper?='*')) 792 * (type=[NamedElement|QualifiedName] exactScope=INT)
504 */ 793 */
505 protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) { 794 protected void sequence_ExactScopeDefinition(ISerializationContext context, ExactScopeDefinition semanticObject) {
506 genericSequencer.createSequence(context, semanticObject); 795 if (errorAcceptor != null) {
796 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE) == ValueTransient.YES)
797 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE));
798 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE) == ValueTransient.YES)
799 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXACT_SCOPE_DEFINITION__EXACT_SCOPE));
800 }
801 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
802 feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getTypeNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.SCOPE_DEFINITION__TYPE, false));
803 feeder.accept(grammarAccess.getExactScopeDefinitionAccess().getExactScopeINTTerminalRuleCall_3_0(), semanticObject.getExactScope());
804 feeder.finish();
507 } 805 }
508 806
509 807
510 /** 808 /**
511 * Contexts: 809 * Contexts:
512 * ComplexObject returns NamedObject 810 * Argument returns ExpressionArgument
513 * Object returns NamedObject 811 * ExpressionArgument returns ExpressionArgument
514 * NamedObject returns NamedObject
515 * Literal returns NamedObject
516 * 812 *
517 * Constraint: 813 * Constraint:
518 * name=ID 814 * body=ComparisonExpression
519 */ 815 */
520 protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) { 816 protected void sequence_ExpressionArgument(ISerializationContext context, ExpressionArgument semanticObject) {
521 if (errorAcceptor != null) { 817 if (errorAcceptor != null) {
522 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES) 818 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY) == ValueTransient.YES)
523 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME)); 819 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXPRESSION_ARGUMENT__BODY));
524 } 820 }
525 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 821 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
526 feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName()); 822 feeder.accept(grammarAccess.getExpressionArgumentAccess().getBodyComparisonExpressionParserRuleCall_0(), semanticObject.getBody());
527 feeder.finish(); 823 feeder.finish();
528 } 824 }
529 825
530 826
531 /** 827 /**
532 * Contexts: 828 * Contexts:
533 * Parameter returns Parameter 829 * Statement returns ExternMetricDefinition
830 * ExternMetricDefinition returns ExternMetricDefinition
534 * 831 *
535 * Constraint: 832 * Constraint:
536 * (variable=Variable type=Symbol?) 833 * (type=MetricType head=Call)
537 */ 834 */
538 protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) { 835 protected void sequence_ExternMetricDefinition(ISerializationContext context, ExternMetricDefinition semanticObject) {
539 genericSequencer.createSequence(context, semanticObject); 836 if (errorAcceptor != null) {
837 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE) == ValueTransient.YES)
838 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__TYPE));
839 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD) == ValueTransient.YES)
840 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_METRIC_DEFINITION__HEAD));
841 }
842 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
843 feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_1_0(), semanticObject.getType());
844 feeder.accept(grammarAccess.getExternMetricDefinitionAccess().getHeadCallParserRuleCall_2_0(), semanticObject.getHead());
845 feeder.finish();
540 } 846 }
541 847
542 848
543 /** 849 /**
544 * Contexts: 850 * Contexts:
545 * PatternBody returns PatternBody 851 * Statement returns ExternPredicateDefinition
852 * ExternPredicateDefinition returns ExternPredicateDefinition
546 * 853 *
547 * Constraint: 854 * Constraint:
548 * constraints+=Constraint* 855 * head=Call
549 */ 856 */
550 protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) { 857 protected void sequence_ExternPredicateDefinition(ISerializationContext context, ExternPredicateDefinition semanticObject) {
551 genericSequencer.createSequence(context, semanticObject); 858 if (errorAcceptor != null) {
859 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD) == ValueTransient.YES)
860 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.EXTERN_PREDICATE_DEFINITION__HEAD));
861 }
862 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
863 feeder.accept(grammarAccess.getExternPredicateDefinitionAccess().getHeadCallParserRuleCall_1_0(), semanticObject.getHead());
864 feeder.finish();
865 }
866
867
868 /**
869 * Contexts:
870 * AssertionOrDefinition.Assertion_1_0_0 returns IfElse
871 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns IfElse
872 * AssertionOrDefinition.MetricDefinition_1_2_0 returns IfElse
873 * Expression returns IfElse
874 * IfElse returns IfElse
875 * DisjunctiveExpression returns IfElse
876 * DisjunctiveExpression.Disjunction_1_0_0 returns IfElse
877 * DisjunctiveExpression.Case_1_1_0 returns IfElse
878 * ConjunctiveExpression returns IfElse
879 * ConjunctiveExpression.Conjunction_1_0 returns IfElse
880 * ComparisonExpression returns IfElse
881 * ComparisonExpression.Comparison_1_0 returns IfElse
882 * AdditiveExpression returns IfElse
883 * AdditiveExpression.BinaryExpression_1_0 returns IfElse
884 * MultiplicativeExpression returns IfElse
885 * MultiplicativeExpression.BinaryExpression_1_0 returns IfElse
886 * ExponentialExpression returns IfElse
887 * ExponentialExpression.BinaryExpression_1_0 returns IfElse
888 * UnaryExpression returns IfElse
889 * AggregationExpression returns IfElse
890 * AtomicExpression returns IfElse
891 *
892 * Constraint:
893 * (condition=Expression then=Expression else=Expression)
894 */
895 protected void sequence_IfElse(ISerializationContext context, IfElse semanticObject) {
896 if (errorAcceptor != null) {
897 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION) == ValueTransient.YES)
898 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__CONDITION));
899 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN) == ValueTransient.YES)
900 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__THEN));
901 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE) == ValueTransient.YES)
902 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.IF_ELSE__ELSE));
903 }
904 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
905 feeder.accept(grammarAccess.getIfElseAccess().getConditionExpressionParserRuleCall_1_0(), semanticObject.getCondition());
906 feeder.accept(grammarAccess.getIfElseAccess().getThenExpressionParserRuleCall_3_0(), semanticObject.getThen());
907 feeder.accept(grammarAccess.getIfElseAccess().getElseExpressionParserRuleCall_5_0(), semanticObject.getElse());
908 feeder.finish();
552 } 909 }
553 910
554 911
555 /** 912 /**
556 * Contexts: 913 * Contexts:
557 * Polarity returns Negative 914 * AssertionOrDefinition.Assertion_1_0_0 returns InfinityLiteral
915 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns InfinityLiteral
916 * AssertionOrDefinition.MetricDefinition_1_2_0 returns InfinityLiteral
917 * Expression returns InfinityLiteral
918 * DisjunctiveExpression returns InfinityLiteral
919 * DisjunctiveExpression.Disjunction_1_0_0 returns InfinityLiteral
920 * DisjunctiveExpression.Case_1_1_0 returns InfinityLiteral
921 * ConjunctiveExpression returns InfinityLiteral
922 * ConjunctiveExpression.Conjunction_1_0 returns InfinityLiteral
923 * ComparisonExpression returns InfinityLiteral
924 * ComparisonExpression.Comparison_1_0 returns InfinityLiteral
925 * AdditiveExpression returns InfinityLiteral
926 * AdditiveExpression.BinaryExpression_1_0 returns InfinityLiteral
927 * MultiplicativeExpression returns InfinityLiteral
928 * MultiplicativeExpression.BinaryExpression_1_0 returns InfinityLiteral
929 * ExponentialExpression returns InfinityLiteral
930 * ExponentialExpression.BinaryExpression_1_0 returns InfinityLiteral
931 * UnaryExpression returns InfinityLiteral
932 * AggregationExpression returns InfinityLiteral
933 * AtomicExpression returns InfinityLiteral
934 * Literal returns InfinityLiteral
935 * InfinityLiteral returns InfinityLiteral
558 * 936 *
559 * Constraint: 937 * Constraint:
560 * {Negative} 938 * {InfinityLiteral}
561 */ 939 */
562 protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) { 940 protected void sequence_InfinityLiteral(ISerializationContext context, InfinityLiteral semanticObject) {
563 genericSequencer.createSequence(context, semanticObject); 941 genericSequencer.createSequence(context, semanticObject);
564 } 942 }
565 943
566 944
567 /** 945 /**
568 * Contexts: 946 * Contexts:
569 * Polarity returns Positive 947 * AssertionOrDefinition.Assertion_1_0_0 returns Interval
948 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Interval
949 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Interval
950 * Expression returns Interval
951 * DisjunctiveExpression returns Interval
952 * DisjunctiveExpression.Disjunction_1_0_0 returns Interval
953 * DisjunctiveExpression.Case_1_1_0 returns Interval
954 * ConjunctiveExpression returns Interval
955 * ConjunctiveExpression.Conjunction_1_0 returns Interval
956 * ComparisonExpression returns Interval
957 * ComparisonExpression.Comparison_1_0 returns Interval
958 * AdditiveExpression returns Interval
959 * AdditiveExpression.BinaryExpression_1_0 returns Interval
960 * MultiplicativeExpression returns Interval
961 * MultiplicativeExpression.BinaryExpression_1_0 returns Interval
962 * ExponentialExpression returns Interval
963 * ExponentialExpression.BinaryExpression_1_0 returns Interval
964 * UnaryExpression returns Interval
965 * AggregationExpression returns Interval
966 * AtomicExpression returns Interval
967 * Interval returns Interval
570 * 968 *
571 * Constraint: 969 * Constraint:
572 * {Positive} 970 * (lowerBound=Expression upperBound=Expression)
573 */ 971 */
574 protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) { 972 protected void sequence_Interval(ISerializationContext context, Interval semanticObject) {
973 if (errorAcceptor != null) {
974 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND) == ValueTransient.YES)
975 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__LOWER_BOUND));
976 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND) == ValueTransient.YES)
977 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INTERVAL__UPPER_BOUND));
978 }
979 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
980 feeder.accept(grammarAccess.getIntervalAccess().getLowerBoundExpressionParserRuleCall_1_0(), semanticObject.getLowerBound());
981 feeder.accept(grammarAccess.getIntervalAccess().getUpperBoundExpressionParserRuleCall_3_0(), semanticObject.getUpperBound());
982 feeder.finish();
983 }
984
985
986 /**
987 * Contexts:
988 * AssertionOrDefinition.Assertion_1_0_0 returns LogicLiteral
989 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns LogicLiteral
990 * AssertionOrDefinition.MetricDefinition_1_2_0 returns LogicLiteral
991 * Expression returns LogicLiteral
992 * DisjunctiveExpression returns LogicLiteral
993 * DisjunctiveExpression.Disjunction_1_0_0 returns LogicLiteral
994 * DisjunctiveExpression.Case_1_1_0 returns LogicLiteral
995 * ConjunctiveExpression returns LogicLiteral
996 * ConjunctiveExpression.Conjunction_1_0 returns LogicLiteral
997 * ComparisonExpression returns LogicLiteral
998 * ComparisonExpression.Comparison_1_0 returns LogicLiteral
999 * AdditiveExpression returns LogicLiteral
1000 * AdditiveExpression.BinaryExpression_1_0 returns LogicLiteral
1001 * MultiplicativeExpression returns LogicLiteral
1002 * MultiplicativeExpression.BinaryExpression_1_0 returns LogicLiteral
1003 * ExponentialExpression returns LogicLiteral
1004 * ExponentialExpression.BinaryExpression_1_0 returns LogicLiteral
1005 * UnaryExpression returns LogicLiteral
1006 * AggregationExpression returns LogicLiteral
1007 * AtomicExpression returns LogicLiteral
1008 * Literal returns LogicLiteral
1009 * LogicLiteral returns LogicLiteral
1010 *
1011 * Constraint:
1012 * value=LogicValue
1013 */
1014 protected void sequence_LogicLiteral(ISerializationContext context, LogicLiteral semanticObject) {
1015 if (errorAcceptor != null) {
1016 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE) == ValueTransient.YES)
1017 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.LOGIC_LITERAL__VALUE));
1018 }
1019 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1020 feeder.accept(grammarAccess.getLogicLiteralAccess().getValueLogicValueEnumRuleCall_0(), semanticObject.getValue());
1021 feeder.finish();
1022 }
1023
1024
1025 /**
1026 * Contexts:
1027 * Statement returns LowerBoundedScopeDefinition
1028 * ScopeDefinition returns LowerBoundedScopeDefinition
1029 * LowerBoundedScopeDefinition returns LowerBoundedScopeDefinition
1030 *
1031 * Constraint:
1032 * ((lowerBound=INT type=[NamedElement|QualifiedName]) | (type=[NamedElement|QualifiedName] lowerBound=INT))
1033 */
1034 protected void sequence_LowerBoundedScopeDefinition(ISerializationContext context, LowerBoundedScopeDefinition semanticObject) {
575 genericSequencer.createSequence(context, semanticObject); 1035 genericSequencer.createSequence(context, semanticObject);
576 } 1036 }
577 1037
578 1038
579 /** 1039 /**
580 * Contexts: 1040 * Contexts:
581 * Statement returns Predicate 1041 * Multiplicity returns ManyMultiplicity
582 * Predicate returns Predicate 1042 * ManyMultiplicity returns ManyMultiplicity
583 * 1043 *
584 * Constraint: 1044 * Constraint:
585 * (isError?='error'? symbol=ModelSymbol (parameters+=Parameter parameters+=Parameter*)? (bodies+=PatternBody bodies+=PatternBody*)?) 1045 * {ManyMultiplicity}
586 */ 1046 */
587 protected void sequence_Predicate(ISerializationContext context, Predicate semanticObject) { 1047 protected void sequence_ManyMultiplicity(ISerializationContext context, ManyMultiplicity semanticObject) {
588 genericSequencer.createSequence(context, semanticObject); 1048 genericSequencer.createSequence(context, semanticObject);
589 } 1049 }
590 1050
591 1051
592 /** 1052 /**
593 * Contexts: 1053 * Contexts:
594 * Problem returns Problem 1054 * MemberDefinition returns MemberDefinition
595 * 1055 *
596 * Constraint: 1056 * Constraint:
597 * statements+=Statement+ 1057 * (containment?='contains'? type=[NamedElement|QualifiedName] multiplicity=Multiplicity? name=ID opposite=[NamedElement|QualifiedName]?)
598 */ 1058 */
599 protected void sequence_Problem(ISerializationContext context, Problem semanticObject) { 1059 protected void sequence_MemberDefinition(ISerializationContext context, MemberDefinition semanticObject) {
600 genericSequencer.createSequence(context, semanticObject); 1060 genericSequencer.createSequence(context, semanticObject);
601 } 1061 }
602 1062
603 1063
604 /** 1064 /**
605 * Contexts: 1065 * Contexts:
606 * ComplexObject returns RealObject 1066 * MetricDefinition returns MetricDefinition
607 * Object returns RealObject
608 * DataObject returns RealObject
609 * RealObject returns RealObject
610 * Literal returns RealObject
611 * 1067 *
612 * Constraint: 1068 * Constraint:
613 * value=REALLiteral 1069 * (type=MetricType head=Expression body=Expression)
614 */ 1070 */
615 protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) { 1071 protected void sequence_MetricDefinition(ISerializationContext context, MetricDefinition semanticObject) {
616 if (errorAcceptor != null) { 1072 if (errorAcceptor != null) {
617 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES) 1073 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE) == ValueTransient.YES)
618 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE)); 1074 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__TYPE));
1075 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD) == ValueTransient.YES)
1076 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__HEAD));
1077 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY) == ValueTransient.YES)
1078 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.METRIC_DEFINITION__BODY));
619 } 1079 }
620 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 1080 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
621 feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue()); 1081 feeder.accept(grammarAccess.getMetricDefinitionAccess().getTypeMetricTypeEnumRuleCall_0_0(), semanticObject.getType());
1082 feeder.accept(grammarAccess.getMetricDefinitionAccess().getHeadExpressionParserRuleCall_1_0(), semanticObject.getHead());
1083 feeder.accept(grammarAccess.getMetricDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody());
622 feeder.finish(); 1084 feeder.finish();
623 } 1085 }
624 1086
625 1087
626 /** 1088 /**
627 * Contexts: 1089 * Contexts:
628 * Symbol returns RealSymbol 1090 * NamedElement returns NamedElement
629 * DataSymbol returns RealSymbol
630 * RealSymbol returns RealSymbol
631 * 1091 *
632 * Constraint: 1092 * Constraint:
633 * {RealSymbol} 1093 * name=QualifiedName
634 */ 1094 */
635 protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) { 1095 protected void sequence_NamedElement(ISerializationContext context, NamedElement semanticObject) {
636 genericSequencer.createSequence(context, semanticObject); 1096 if (errorAcceptor != null) {
1097 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME) == ValueTransient.YES)
1098 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_ELEMENT__NAME));
1099 }
1100 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1101 feeder.accept(grammarAccess.getNamedElementAccess().getNameQualifiedNameParserRuleCall_0(), semanticObject.getName());
1102 feeder.finish();
637 } 1103 }
638 1104
639 1105
640 /** 1106 /**
641 * Contexts: 1107 * Contexts:
642 * ComplexObject returns StringObject 1108 * AssertionOrDefinition.Assertion_1_0_0 returns NumericLiteral
643 * Object returns StringObject 1109 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns NumericLiteral
644 * DataObject returns StringObject 1110 * AssertionOrDefinition.MetricDefinition_1_2_0 returns NumericLiteral
645 * StringObject returns StringObject 1111 * Expression returns NumericLiteral
646 * Literal returns StringObject 1112 * DisjunctiveExpression returns NumericLiteral
1113 * DisjunctiveExpression.Disjunction_1_0_0 returns NumericLiteral
1114 * DisjunctiveExpression.Case_1_1_0 returns NumericLiteral
1115 * ConjunctiveExpression returns NumericLiteral
1116 * ConjunctiveExpression.Conjunction_1_0 returns NumericLiteral
1117 * ComparisonExpression returns NumericLiteral
1118 * ComparisonExpression.Comparison_1_0 returns NumericLiteral
1119 * AdditiveExpression returns NumericLiteral
1120 * AdditiveExpression.BinaryExpression_1_0 returns NumericLiteral
1121 * MultiplicativeExpression returns NumericLiteral
1122 * MultiplicativeExpression.BinaryExpression_1_0 returns NumericLiteral
1123 * ExponentialExpression returns NumericLiteral
1124 * ExponentialExpression.BinaryExpression_1_0 returns NumericLiteral
1125 * UnaryExpression returns NumericLiteral
1126 * AggregationExpression returns NumericLiteral
1127 * AtomicExpression returns NumericLiteral
1128 * Literal returns NumericLiteral
1129 * NumericLiteral returns NumericLiteral
647 * 1130 *
648 * Constraint: 1131 * Constraint:
649 * value=STRING 1132 * value=Real
650 */ 1133 */
651 protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) { 1134 protected void sequence_NumericLiteral(ISerializationContext context, NumericLiteral semanticObject) {
652 if (errorAcceptor != null) { 1135 if (errorAcceptor != null) {
653 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES) 1136 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE) == ValueTransient.YES)
654 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE)); 1137 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NUMERIC_LITERAL__VALUE));
655 } 1138 }
656 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 1139 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
657 feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue()); 1140 feeder.accept(grammarAccess.getNumericLiteralAccess().getValueRealParserRuleCall_0(), semanticObject.getValue());
658 feeder.finish(); 1141 feeder.finish();
659 } 1142 }
660 1143
661 1144
662 /** 1145 /**
663 * Contexts: 1146 * Contexts:
664 * Symbol returns StringSymbol 1147 * Statement returns ObjectiveDefinition
665 * DataSymbol returns StringSymbol 1148 * ObjectiveDefinition returns ObjectiveDefinition
666 * StringSymbol returns StringSymbol
667 * 1149 *
668 * Constraint: 1150 * Constraint:
669 * {StringSymbol} 1151 * (kind=ObjectiveKind objective=Expression)
670 */ 1152 */
671 protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) { 1153 protected void sequence_ObjectiveDefinition(ISerializationContext context, ObjectiveDefinition semanticObject) {
672 genericSequencer.createSequence(context, semanticObject); 1154 if (errorAcceptor != null) {
1155 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND) == ValueTransient.YES)
1156 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__KIND));
1157 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE) == ValueTransient.YES)
1158 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.OBJECTIVE_DEFINITION__OBJECTIVE));
1159 }
1160 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1161 feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getKindObjectiveKindEnumRuleCall_0_0(), semanticObject.getKind());
1162 feeder.accept(grammarAccess.getObjectiveDefinitionAccess().getObjectiveExpressionParserRuleCall_1_0(), semanticObject.getObjective());
1163 feeder.finish();
673 } 1164 }
674 1165
675 1166
676 /** 1167 /**
677 * Contexts: 1168 * Contexts:
678 * TruthValue returns Error 1169 * PredicateDefinition returns PredicateDefinition
679 * 1170 *
680 * Constraint: 1171 * Constraint:
681 * {Error} 1172 * (((functional?='functional' error?='error'?) | (error?='error' functional?='functional'?)) head=Call body=Expression)
682 */ 1173 */
683 protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) { 1174 protected void sequence_PredicateDefinition(ISerializationContext context, PredicateDefinition semanticObject) {
684 genericSequencer.createSequence(context, semanticObject); 1175 genericSequencer.createSequence(context, semanticObject);
685 } 1176 }
686 1177
687 1178
688 /** 1179 /**
689 * Contexts: 1180 * Contexts:
690 * TruthValue returns False 1181 * Problem returns Problem
691 * 1182 *
692 * Constraint: 1183 * Constraint:
693 * {False} 1184 * statements+=Statement+
694 */ 1185 */
695 protected void sequence_TruthValue(ISerializationContext context, False semanticObject) { 1186 protected void sequence_Problem(ISerializationContext context, Problem semanticObject) {
696 genericSequencer.createSequence(context, semanticObject); 1187 genericSequencer.createSequence(context, semanticObject);
697 } 1188 }
698 1189
699 1190
700 /** 1191 /**
701 * Contexts: 1192 * Contexts:
702 * TruthValue returns True 1193 * AssertionOrDefinition.Assertion_1_0_0 returns Reference
1194 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns Reference
1195 * AssertionOrDefinition.MetricDefinition_1_2_0 returns Reference
1196 * Expression returns Reference
1197 * DisjunctiveExpression returns Reference
1198 * DisjunctiveExpression.Disjunction_1_0_0 returns Reference
1199 * DisjunctiveExpression.Case_1_1_0 returns Reference
1200 * ConjunctiveExpression returns Reference
1201 * ConjunctiveExpression.Conjunction_1_0 returns Reference
1202 * ComparisonExpression returns Reference
1203 * ComparisonExpression.Comparison_1_0 returns Reference
1204 * AdditiveExpression returns Reference
1205 * AdditiveExpression.BinaryExpression_1_0 returns Reference
1206 * MultiplicativeExpression returns Reference
1207 * MultiplicativeExpression.BinaryExpression_1_0 returns Reference
1208 * ExponentialExpression returns Reference
1209 * ExponentialExpression.BinaryExpression_1_0 returns Reference
1210 * UnaryExpression returns Reference
1211 * AggregationExpression returns Reference
1212 * AtomicExpression returns Reference
1213 * Reference returns Reference
703 * 1214 *
704 * Constraint: 1215 * Constraint:
705 * {True} 1216 * referred=[NamedElement|QualifiedName]
706 */ 1217 */
707 protected void sequence_TruthValue(ISerializationContext context, True semanticObject) { 1218 protected void sequence_Reference(ISerializationContext context, Reference semanticObject) {
708 genericSequencer.createSequence(context, semanticObject); 1219 if (errorAcceptor != null) {
1220 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED) == ValueTransient.YES)
1221 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REFERENCE__REFERRED));
1222 }
1223 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1224 feeder.accept(grammarAccess.getReferenceAccess().getReferredNamedElementQualifiedNameParserRuleCall_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.REFERENCE__REFERRED, false));
1225 feeder.finish();
709 } 1226 }
710 1227
711 1228
712 /** 1229 /**
713 * Contexts: 1230 * Contexts:
714 * TruthValue returns Unknown 1231 * Argument returns StarArgument
1232 * StarArgument returns StarArgument
715 * 1233 *
716 * Constraint: 1234 * Constraint:
717 * {Unknown} 1235 * {StarArgument}
718 */ 1236 */
719 protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) { 1237 protected void sequence_StarArgument(ISerializationContext context, StarArgument semanticObject) {
720 genericSequencer.createSequence(context, semanticObject); 1238 genericSequencer.createSequence(context, semanticObject);
721 } 1239 }
722 1240
723 1241
724 /** 1242 /**
725 * Contexts: 1243 * Contexts:
726 * ComplexObject returns UnnamedObject 1244 * AssertionOrDefinition.Assertion_1_0_0 returns StringLiteral
727 * Object returns UnnamedObject 1245 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns StringLiteral
728 * UnnamedObject returns UnnamedObject 1246 * AssertionOrDefinition.MetricDefinition_1_2_0 returns StringLiteral
1247 * Expression returns StringLiteral
1248 * DisjunctiveExpression returns StringLiteral
1249 * DisjunctiveExpression.Disjunction_1_0_0 returns StringLiteral
1250 * DisjunctiveExpression.Case_1_1_0 returns StringLiteral
1251 * ConjunctiveExpression returns StringLiteral
1252 * ConjunctiveExpression.Conjunction_1_0 returns StringLiteral
1253 * ComparisonExpression returns StringLiteral
1254 * ComparisonExpression.Comparison_1_0 returns StringLiteral
1255 * AdditiveExpression returns StringLiteral
1256 * AdditiveExpression.BinaryExpression_1_0 returns StringLiteral
1257 * MultiplicativeExpression returns StringLiteral
1258 * MultiplicativeExpression.BinaryExpression_1_0 returns StringLiteral
1259 * ExponentialExpression returns StringLiteral
1260 * ExponentialExpression.BinaryExpression_1_0 returns StringLiteral
1261 * UnaryExpression returns StringLiteral
1262 * AggregationExpression returns StringLiteral
1263 * AtomicExpression returns StringLiteral
1264 * Literal returns StringLiteral
1265 * StringLiteral returns StringLiteral
1266 *
1267 * Constraint:
1268 * value=STRING
1269 */
1270 protected void sequence_StringLiteral(ISerializationContext context, StringLiteral semanticObject) {
1271 if (errorAcceptor != null) {
1272 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES)
1273 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_LITERAL__VALUE));
1274 }
1275 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1276 feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
1277 feeder.finish();
1278 }
1279
1280
1281 /**
1282 * Contexts:
1283 * Argument returns TypedArgument
1284 * TypedArgument returns TypedArgument
1285 *
1286 * Constraint:
1287 * (type=[NamedElement|QualifiedName] variable=[NamedElement|QualifiedName])
1288 */
1289 protected void sequence_TypedArgument(ISerializationContext context, TypedArgument semanticObject) {
1290 if (errorAcceptor != null) {
1291 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE) == ValueTransient.YES)
1292 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE));
1293 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE) == ValueTransient.YES)
1294 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE));
1295 }
1296 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1297 feeder.accept(grammarAccess.getTypedArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__TYPE, false));
1298 feeder.accept(grammarAccess.getTypedArgumentAccess().getVariableNamedElementQualifiedNameParserRuleCall_1_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_ARGUMENT__VARIABLE, false));
1299 feeder.finish();
1300 }
1301
1302
1303 /**
1304 * Contexts:
1305 * Argument returns TypedStarArgument
1306 * TypedStarArgument returns TypedStarArgument
1307 *
1308 * Constraint:
1309 * type=[NamedElement|QualifiedName]
1310 */
1311 protected void sequence_TypedStarArgument(ISerializationContext context, TypedStarArgument semanticObject) {
1312 if (errorAcceptor != null) {
1313 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE) == ValueTransient.YES)
1314 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE));
1315 }
1316 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
1317 feeder.accept(grammarAccess.getTypedStarArgumentAccess().getTypeNamedElementQualifiedNameParserRuleCall_0_0_1(), semanticObject.eGet(SolverLanguagePackage.Literals.TYPED_STAR_ARGUMENT__TYPE, false));
1318 feeder.finish();
1319 }
1320
1321
1322 /**
1323 * Contexts:
1324 * AssertionOrDefinition.Assertion_1_0_0 returns UnaryExpression
1325 * AssertionOrDefinition.PredicateDefinition_1_1_0 returns UnaryExpression
1326 * AssertionOrDefinition.MetricDefinition_1_2_0 returns UnaryExpression
1327 * Expression returns UnaryExpression
1328 * DisjunctiveExpression returns UnaryExpression
1329 * DisjunctiveExpression.Disjunction_1_0_0 returns UnaryExpression
1330 * DisjunctiveExpression.Case_1_1_0 returns UnaryExpression
1331 * ConjunctiveExpression returns UnaryExpression
1332 * ConjunctiveExpression.Conjunction_1_0 returns UnaryExpression
1333 * ComparisonExpression returns UnaryExpression
1334 * ComparisonExpression.Comparison_1_0 returns UnaryExpression
1335 * AdditiveExpression returns UnaryExpression
1336 * AdditiveExpression.BinaryExpression_1_0 returns UnaryExpression
1337 * MultiplicativeExpression returns UnaryExpression
1338 * MultiplicativeExpression.BinaryExpression_1_0 returns UnaryExpression
1339 * ExponentialExpression returns UnaryExpression
1340 * ExponentialExpression.BinaryExpression_1_0 returns UnaryExpression
1341 * UnaryExpression returns UnaryExpression
1342 * AggregationExpression returns UnaryExpression
1343 * AtomicExpression returns UnaryExpression
729 * 1344 *
730 * Constraint: 1345 * Constraint:
731 * name=ID 1346 * (op=UnaryOp body=AggregationExpression)
732 */ 1347 */
733 protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) { 1348 protected void sequence_UnaryExpression(ISerializationContext context, UnaryExpression semanticObject) {
734 if (errorAcceptor != null) { 1349 if (errorAcceptor != null) {
735 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES) 1350 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP) == ValueTransient.YES)
736 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME)); 1351 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__OP));
1352 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY) == ValueTransient.YES)
1353 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNARY_EXPRESSION__BODY));
737 } 1354 }
738 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 1355 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
739 feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); 1356 feeder.accept(grammarAccess.getUnaryExpressionAccess().getOpUnaryOpEnumRuleCall_1_1_0(), semanticObject.getOp());
1357 feeder.accept(grammarAccess.getUnaryExpressionAccess().getBodyAggregationExpressionParserRuleCall_1_2_0(), semanticObject.getBody());
740 feeder.finish(); 1358 feeder.finish();
741 } 1359 }
742 1360
743 1361
744 /** 1362 /**
745 * Contexts: 1363 * Contexts:
746 * Literal returns Variable 1364 * Statement returns UnnamedErrorPrediateDefinition
747 * Variable returns Variable 1365 * UnnamedErrorPrediateDefinition returns UnnamedErrorPrediateDefinition
748 * 1366 *
749 * Constraint: 1367 * Constraint:
750 * name=ID 1368 * (argumentList=ArgumentList body=Expression)
751 */ 1369 */
752 protected void sequence_Variable(ISerializationContext context, Variable semanticObject) { 1370 protected void sequence_UnnamedErrorPrediateDefinition(ISerializationContext context, UnnamedErrorPrediateDefinition semanticObject) {
753 if (errorAcceptor != null) { 1371 if (errorAcceptor != null) {
754 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES) 1372 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST) == ValueTransient.YES)
755 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME)); 1373 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__ARGUMENT_LIST));
1374 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY) == ValueTransient.YES)
1375 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_ERROR_PREDIATE_DEFINITION__BODY));
756 } 1376 }
757 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); 1377 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
758 feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); 1378 feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getArgumentListArgumentListParserRuleCall_1_0(), semanticObject.getArgumentList());
1379 feeder.accept(grammarAccess.getUnnamedErrorPrediateDefinitionAccess().getBodyExpressionParserRuleCall_3_0(), semanticObject.getBody());
759 feeder.finish(); 1380 feeder.finish();
760 } 1381 }
761 1382
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-03 17:14:19 +0000