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.java781
1 files changed, 781 insertions, 0 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
new file mode 100644
index 00000000..80f9a02e
--- /dev/null
+++ b/Application/org.eclipse.viatra.solver.language/src-gen/org/eclipse/viatra/solver/language/serializer/SolverLanguageSemanticSequencer.java
@@ -0,0 +1,781 @@
1/*
2 * generated by Xtext 2.18.0.M3
3 */
4package org.eclipse.viatra.solver.language.serializer;
5
6import com.google.inject.Inject;
7import java.util.Set;
8import org.eclipse.emf.ecore.EObject;
9import org.eclipse.emf.ecore.EPackage;
10import org.eclipse.viatra.solver.language.services.SolverLanguageGrammarAccess;
11import org.eclipse.viatra.solver.language.solverLanguage.AllInstances;
12import org.eclipse.viatra.solver.language.solverLanguage.AllObjects;
13import org.eclipse.viatra.solver.language.solverLanguage.BasicInterpretation;
14import org.eclipse.viatra.solver.language.solverLanguage.BooleanFalse;
15import org.eclipse.viatra.solver.language.solverLanguage.BooleanObject;
16import org.eclipse.viatra.solver.language.solverLanguage.BooleanSymbol;
17import org.eclipse.viatra.solver.language.solverLanguage.BooleanTrue;
18import org.eclipse.viatra.solver.language.solverLanguage.ClassInterpretation;
19import org.eclipse.viatra.solver.language.solverLanguage.Constraint;
20import org.eclipse.viatra.solver.language.solverLanguage.DefaultInterpretation;
21import org.eclipse.viatra.solver.language.solverLanguage.EnumInterpretation;
22import org.eclipse.viatra.solver.language.solverLanguage.EqualsSymbol;
23import org.eclipse.viatra.solver.language.solverLanguage.ErrorPredicate;
24import org.eclipse.viatra.solver.language.solverLanguage.ExistSymbol;
25import org.eclipse.viatra.solver.language.solverLanguage.False;
26import org.eclipse.viatra.solver.language.solverLanguage.FieldRelationInterpretation;
27import org.eclipse.viatra.solver.language.solverLanguage.GlobalRelationInterpretation;
28import org.eclipse.viatra.solver.language.solverLanguage.IntObject;
29import org.eclipse.viatra.solver.language.solverLanguage.IntegerSymbol;
30import org.eclipse.viatra.solver.language.solverLanguage.IrreflexiveClosure;
31import org.eclipse.viatra.solver.language.solverLanguage.ModelSymbol;
32import org.eclipse.viatra.solver.language.solverLanguage.MultiplicityDefinition;
33import org.eclipse.viatra.solver.language.solverLanguage.NamedObject;
34import org.eclipse.viatra.solver.language.solverLanguage.Negative;
35import org.eclipse.viatra.solver.language.solverLanguage.PatternBody;
36import org.eclipse.viatra.solver.language.solverLanguage.Positive;
37import org.eclipse.viatra.solver.language.solverLanguage.PredicateSymbol;
38import org.eclipse.viatra.solver.language.solverLanguage.Problem;
39import org.eclipse.viatra.solver.language.solverLanguage.RealObject;
40import org.eclipse.viatra.solver.language.solverLanguage.RealSymbol;
41import org.eclipse.viatra.solver.language.solverLanguage.ReflexiveClosure;
42import org.eclipse.viatra.solver.language.solverLanguage.SolverLanguagePackage;
43import org.eclipse.viatra.solver.language.solverLanguage.StringObject;
44import org.eclipse.viatra.solver.language.solverLanguage.StringSymbol;
45import org.eclipse.viatra.solver.language.solverLanguage.True;
46import org.eclipse.viatra.solver.language.solverLanguage.Unknown;
47import org.eclipse.viatra.solver.language.solverLanguage.UnnamedObject;
48import org.eclipse.viatra.solver.language.solverLanguage.Variable;
49import org.eclipse.xtext.Action;
50import org.eclipse.xtext.Parameter;
51import org.eclipse.xtext.ParserRule;
52import org.eclipse.xtext.serializer.ISerializationContext;
53import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
54import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
55import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
56
57@SuppressWarnings("all")
58public class SolverLanguageSemanticSequencer extends AbstractDelegatingSemanticSequencer {
59
60 @Inject
61 private SolverLanguageGrammarAccess grammarAccess;
62
63 @Override
64 public void sequence(ISerializationContext context, EObject semanticObject) {
65 EPackage epackage = semanticObject.eClass().getEPackage();
66 ParserRule rule = context.getParserRule();
67 Action action = context.getAssignedAction();
68 Set<Parameter> parameters = context.getEnabledBooleanParameters();
69 if (epackage == SolverLanguagePackage.eINSTANCE)
70 switch (semanticObject.eClass().getClassifierID()) {
71 case SolverLanguagePackage.ALL_INSTANCES:
72 sequence_AllInstances(context, (AllInstances) semanticObject);
73 return;
74 case SolverLanguagePackage.ALL_OBJECTS:
75 sequence_AllObjects(context, (AllObjects) semanticObject);
76 return;
77 case SolverLanguagePackage.BASIC_INTERPRETATION:
78 sequence_BasicInterpretation(context, (BasicInterpretation) semanticObject);
79 return;
80 case SolverLanguagePackage.BOOLEAN_FALSE:
81 sequence_BooleanValue(context, (BooleanFalse) semanticObject);
82 return;
83 case SolverLanguagePackage.BOOLEAN_OBJECT:
84 sequence_BooleanObject(context, (BooleanObject) semanticObject);
85 return;
86 case SolverLanguagePackage.BOOLEAN_SYMBOL:
87 sequence_BooleanSymbol(context, (BooleanSymbol) semanticObject);
88 return;
89 case SolverLanguagePackage.BOOLEAN_TRUE:
90 sequence_BooleanValue(context, (BooleanTrue) semanticObject);
91 return;
92 case SolverLanguagePackage.CLASS_INTERPRETATION:
93 sequence_ClassInterpretation(context, (ClassInterpretation) semanticObject);
94 return;
95 case SolverLanguagePackage.CONSTRAINT:
96 sequence_Constraint(context, (Constraint) semanticObject);
97 return;
98 case SolverLanguagePackage.DEFAULT_INTERPRETATION:
99 sequence_DefaultInterpretation(context, (DefaultInterpretation) semanticObject);
100 return;
101 case SolverLanguagePackage.ENUM_INTERPRETATION:
102 sequence_EnumInterpretation(context, (EnumInterpretation) semanticObject);
103 return;
104 case SolverLanguagePackage.EQUALS_SYMBOL:
105 sequence_EqualsSymbol(context, (EqualsSymbol) semanticObject);
106 return;
107 case SolverLanguagePackage.ERROR:
108 sequence_TruthValue(context, (org.eclipse.viatra.solver.language.solverLanguage.Error) semanticObject);
109 return;
110 case SolverLanguagePackage.ERROR_PREDICATE:
111 sequence_ErrorPredicate(context, (ErrorPredicate) semanticObject);
112 return;
113 case SolverLanguagePackage.EXIST_SYMBOL:
114 sequence_ExistSymbol(context, (ExistSymbol) semanticObject);
115 return;
116 case SolverLanguagePackage.FALSE:
117 sequence_TruthValue(context, (False) semanticObject);
118 return;
119 case SolverLanguagePackage.FIELD_RELATION_INTERPRETATION:
120 sequence_FieldRelationInterpretation(context, (FieldRelationInterpretation) semanticObject);
121 return;
122 case SolverLanguagePackage.GLOBAL_RELATION_INTERPRETATION:
123 sequence_GlobalRelationInterpretation(context, (GlobalRelationInterpretation) semanticObject);
124 return;
125 case SolverLanguagePackage.INT_OBJECT:
126 sequence_IntObject(context, (IntObject) semanticObject);
127 return;
128 case SolverLanguagePackage.INTEGER_SYMBOL:
129 sequence_IntegerSymbol(context, (IntegerSymbol) semanticObject);
130 return;
131 case SolverLanguagePackage.IRREFLEXIVE_CLOSURE:
132 sequence_ClosureType(context, (IrreflexiveClosure) semanticObject);
133 return;
134 case SolverLanguagePackage.MODEL_SYMBOL:
135 sequence_ModelSymbol(context, (ModelSymbol) semanticObject);
136 return;
137 case SolverLanguagePackage.MULTIPLICITY_DEFINITION:
138 sequence_MultiplicityDefinition(context, (MultiplicityDefinition) semanticObject);
139 return;
140 case SolverLanguagePackage.NAMED_OBJECT:
141 sequence_NamedObject(context, (NamedObject) semanticObject);
142 return;
143 case SolverLanguagePackage.NEGATIVE:
144 sequence_Polarity(context, (Negative) semanticObject);
145 return;
146 case SolverLanguagePackage.PARAMETER:
147 sequence_Parameter(context, (org.eclipse.viatra.solver.language.solverLanguage.Parameter) semanticObject);
148 return;
149 case SolverLanguagePackage.PATTERN_BODY:
150 sequence_PatternBody(context, (PatternBody) semanticObject);
151 return;
152 case SolverLanguagePackage.POSITIVE:
153 sequence_Polarity(context, (Positive) semanticObject);
154 return;
155 case SolverLanguagePackage.PREDICATE_SYMBOL:
156 sequence_PredicateSymbol(context, (PredicateSymbol) semanticObject);
157 return;
158 case SolverLanguagePackage.PROBLEM:
159 sequence_Problem(context, (Problem) semanticObject);
160 return;
161 case SolverLanguagePackage.REAL_OBJECT:
162 sequence_RealObject(context, (RealObject) semanticObject);
163 return;
164 case SolverLanguagePackage.REAL_SYMBOL:
165 sequence_RealSymbol(context, (RealSymbol) semanticObject);
166 return;
167 case SolverLanguagePackage.REFLEXIVE_CLOSURE:
168 sequence_ClosureType(context, (ReflexiveClosure) semanticObject);
169 return;
170 case SolverLanguagePackage.STRING_OBJECT:
171 sequence_StringObject(context, (StringObject) semanticObject);
172 return;
173 case SolverLanguagePackage.STRING_SYMBOL:
174 sequence_StringSymbol(context, (StringSymbol) semanticObject);
175 return;
176 case SolverLanguagePackage.TRUE:
177 sequence_TruthValue(context, (True) semanticObject);
178 return;
179 case SolverLanguagePackage.UNKNOWN:
180 sequence_TruthValue(context, (Unknown) semanticObject);
181 return;
182 case SolverLanguagePackage.UNNAMED_OBJECT:
183 sequence_UnnamedObject(context, (UnnamedObject) semanticObject);
184 return;
185 case SolverLanguagePackage.VARIABLE:
186 sequence_Variable(context, (Variable) semanticObject);
187 return;
188 }
189 if (errorAcceptor != null)
190 errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
191 }
192
193 /**
194 * Contexts:
195 * ComplexObject returns AllInstances
196 * AllInstances returns AllInstances
197 *
198 * Constraint:
199 * symbol=Symbol
200 */
201 protected void sequence_AllInstances(ISerializationContext context, AllInstances semanticObject) {
202 if (errorAcceptor != null) {
203 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL) == ValueTransient.YES)
204 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.ALL_INSTANCES__SYMBOL));
205 }
206 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
207 feeder.accept(grammarAccess.getAllInstancesAccess().getSymbolSymbolParserRuleCall_1_0(), semanticObject.getSymbol());
208 feeder.finish();
209 }
210
211
212 /**
213 * Contexts:
214 * ComplexObject returns AllObjects
215 * AllObjects returns AllObjects
216 *
217 * Constraint:
218 * {AllObjects}
219 */
220 protected void sequence_AllObjects(ISerializationContext context, AllObjects semanticObject) {
221 genericSequencer.createSequence(context, semanticObject);
222 }
223
224
225 /**
226 * Contexts:
227 * Statement returns BasicInterpretation
228 * Interpretation returns BasicInterpretation
229 * BasicInterpretation returns BasicInterpretation
230 *
231 * Constraint:
232 * (symbol=Symbol objects+=ComplexObject* value=TruthValue)
233 */
234 protected void sequence_BasicInterpretation(ISerializationContext context, BasicInterpretation semanticObject) {
235 genericSequencer.createSequence(context, semanticObject);
236 }
237
238
239 /**
240 * Contexts:
241 * ComplexObject returns BooleanObject
242 * Object returns BooleanObject
243 * DataObject returns BooleanObject
244 * BooleanObject returns BooleanObject
245 * Literal returns BooleanObject
246 *
247 * Constraint:
248 * value=BooleanValue
249 */
250 protected void sequence_BooleanObject(ISerializationContext context, BooleanObject semanticObject) {
251 if (errorAcceptor != null) {
252 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE) == ValueTransient.YES)
253 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.BOOLEAN_OBJECT__VALUE));
254 }
255 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
256 feeder.accept(grammarAccess.getBooleanObjectAccess().getValueBooleanValueParserRuleCall_0(), semanticObject.getValue());
257 feeder.finish();
258 }
259
260
261 /**
262 * Contexts:
263 * Symbol returns BooleanSymbol
264 * DataSymbol returns BooleanSymbol
265 * BooleanSymbol returns BooleanSymbol
266 *
267 * Constraint:
268 * {BooleanSymbol}
269 */
270 protected void sequence_BooleanSymbol(ISerializationContext context, BooleanSymbol semanticObject) {
271 genericSequencer.createSequence(context, semanticObject);
272 }
273
274
275 /**
276 * Contexts:
277 * BooleanValue returns BooleanFalse
278 *
279 * Constraint:
280 * {BooleanFalse}
281 */
282 protected void sequence_BooleanValue(ISerializationContext context, BooleanFalse semanticObject) {
283 genericSequencer.createSequence(context, semanticObject);
284 }
285
286
287 /**
288 * Contexts:
289 * BooleanValue returns BooleanTrue
290 *
291 * Constraint:
292 * {BooleanTrue}
293 */
294 protected void sequence_BooleanValue(ISerializationContext context, BooleanTrue semanticObject) {
295 genericSequencer.createSequence(context, semanticObject);
296 }
297
298
299 /**
300 * Contexts:
301 * Statement returns ClassInterpretation
302 * Interpretation returns ClassInterpretation
303 * CDInterpretation returns ClassInterpretation
304 * ClassInterpretation returns ClassInterpretation
305 *
306 * Constraint:
307 * (abstract?='abstract' symbol=ModelSymbol supertypes+=ModelSymbol* fielt+=FieldRelationInterpretation*)
308 */
309 protected void sequence_ClassInterpretation(ISerializationContext context, ClassInterpretation semanticObject) {
310 genericSequencer.createSequence(context, semanticObject);
311 }
312
313
314 /**
315 * Contexts:
316 * ClosureType returns IrreflexiveClosure
317 *
318 * Constraint:
319 * {IrreflexiveClosure}
320 */
321 protected void sequence_ClosureType(ISerializationContext context, IrreflexiveClosure semanticObject) {
322 genericSequencer.createSequence(context, semanticObject);
323 }
324
325
326 /**
327 * Contexts:
328 * ClosureType returns ReflexiveClosure
329 *
330 * Constraint:
331 * {ReflexiveClosure}
332 */
333 protected void sequence_ClosureType(ISerializationContext context, ReflexiveClosure semanticObject) {
334 genericSequencer.createSequence(context, semanticObject);
335 }
336
337
338 /**
339 * Contexts:
340 * Constraint returns Constraint
341 *
342 * Constraint:
343 * (polarity=Polarity? symbol=ModelSymbol (params+=Literal+ | (closureType=ClosureType params+=Literal params+=Literal))?)
344 */
345 protected void sequence_Constraint(ISerializationContext context, Constraint semanticObject) {
346 genericSequencer.createSequence(context, semanticObject);
347 }
348
349
350 /**
351 * Contexts:
352 * Statement returns DefaultInterpretation
353 * Interpretation returns DefaultInterpretation
354 * DefaultInterpretation returns DefaultInterpretation
355 *
356 * Constraint:
357 * interpretation=BasicInterpretation
358 */
359 protected void sequence_DefaultInterpretation(ISerializationContext context, DefaultInterpretation semanticObject) {
360 if (errorAcceptor != null) {
361 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION) == ValueTransient.YES)
362 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.DEFAULT_INTERPRETATION__INTERPRETATION));
363 }
364 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
365 feeder.accept(grammarAccess.getDefaultInterpretationAccess().getInterpretationBasicInterpretationParserRuleCall_1_0(), semanticObject.getInterpretation());
366 feeder.finish();
367 }
368
369
370 /**
371 * Contexts:
372 * Statement returns EnumInterpretation
373 * Interpretation returns EnumInterpretation
374 * CDInterpretation returns EnumInterpretation
375 * EnumInterpretation returns EnumInterpretation
376 *
377 * Constraint:
378 * (Symbol=ModelSymbol objects+=NamedObject+)
379 */
380 protected void sequence_EnumInterpretation(ISerializationContext context, EnumInterpretation semanticObject) {
381 genericSequencer.createSequence(context, semanticObject);
382 }
383
384
385 /**
386 * Contexts:
387 * Symbol returns EqualsSymbol
388 * PartialitySymbol returns EqualsSymbol
389 * EqualsSymbol returns EqualsSymbol
390 *
391 * Constraint:
392 * {EqualsSymbol}
393 */
394 protected void sequence_EqualsSymbol(ISerializationContext context, EqualsSymbol semanticObject) {
395 genericSequencer.createSequence(context, semanticObject);
396 }
397
398
399 /**
400 * Contexts:
401 * Statement returns ErrorPredicate
402 * Predicate returns ErrorPredicate
403 * ErrorPredicate returns ErrorPredicate
404 *
405 * Constraint:
406 * (name=ID? parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?)
407 */
408 protected void sequence_ErrorPredicate(ISerializationContext context, ErrorPredicate semanticObject) {
409 genericSequencer.createSequence(context, semanticObject);
410 }
411
412
413 /**
414 * Contexts:
415 * Symbol returns ExistSymbol
416 * PartialitySymbol returns ExistSymbol
417 * ExistSymbol returns ExistSymbol
418 *
419 * Constraint:
420 * {ExistSymbol}
421 */
422 protected void sequence_ExistSymbol(ISerializationContext context, ExistSymbol semanticObject) {
423 genericSequencer.createSequence(context, semanticObject);
424 }
425
426
427 /**
428 * Contexts:
429 * FieldRelationInterpretation returns FieldRelationInterpretation
430 *
431 * Constraint:
432 * (containment?='containment' symbol=ModelSymbol multiplicity=MultiplicityDefinition? target=Symbol)
433 */
434 protected void sequence_FieldRelationInterpretation(ISerializationContext context, FieldRelationInterpretation semanticObject) {
435 genericSequencer.createSequence(context, semanticObject);
436 }
437
438
439 /**
440 * Contexts:
441 * Statement returns GlobalRelationInterpretation
442 * Interpretation returns GlobalRelationInterpretation
443 * CDInterpretation returns GlobalRelationInterpretation
444 * GlobalRelationInterpretation returns GlobalRelationInterpretation
445 *
446 * Constraint:
447 * (
448 * containment?='containment'
449 * symbol=ModelSymbol
450 * sourceMultiplicity=MultiplicityDefinition?
451 * source=Symbol
452 * targetMultiplicity=MultiplicityDefinition?
453 * target=Symbol
454 * )
455 */
456 protected void sequence_GlobalRelationInterpretation(ISerializationContext context, GlobalRelationInterpretation semanticObject) {
457 genericSequencer.createSequence(context, semanticObject);
458 }
459
460
461 /**
462 * Contexts:
463 * ComplexObject returns IntObject
464 * Object returns IntObject
465 * DataObject returns IntObject
466 * IntObject returns IntObject
467 * Literal returns IntObject
468 *
469 * Constraint:
470 * value=INTLiteral
471 */
472 protected void sequence_IntObject(ISerializationContext context, IntObject semanticObject) {
473 if (errorAcceptor != null) {
474 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE) == ValueTransient.YES)
475 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.INT_OBJECT__VALUE));
476 }
477 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
478 feeder.accept(grammarAccess.getIntObjectAccess().getValueINTLiteralParserRuleCall_0(), semanticObject.getValue());
479 feeder.finish();
480 }
481
482
483 /**
484 * Contexts:
485 * Symbol returns IntegerSymbol
486 * DataSymbol returns IntegerSymbol
487 * IntegerSymbol returns IntegerSymbol
488 *
489 * Constraint:
490 * {IntegerSymbol}
491 */
492 protected void sequence_IntegerSymbol(ISerializationContext context, IntegerSymbol semanticObject) {
493 genericSequencer.createSequence(context, semanticObject);
494 }
495
496
497 /**
498 * Contexts:
499 * Symbol returns ModelSymbol
500 * ModelSymbol returns ModelSymbol
501 *
502 * Constraint:
503 * name=ID
504 */
505 protected void sequence_ModelSymbol(ISerializationContext context, ModelSymbol semanticObject) {
506 if (errorAcceptor != null) {
507 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME) == ValueTransient.YES)
508 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.MODEL_SYMBOL__NAME));
509 }
510 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
511 feeder.accept(grammarAccess.getModelSymbolAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
512 feeder.finish();
513 }
514
515
516 /**
517 * Contexts:
518 * MultiplicityDefinition returns MultiplicityDefinition
519 *
520 * Constraint:
521 * (lower=INT (upper=INT | unlimitedUpper?='*'))
522 */
523 protected void sequence_MultiplicityDefinition(ISerializationContext context, MultiplicityDefinition semanticObject) {
524 genericSequencer.createSequence(context, semanticObject);
525 }
526
527
528 /**
529 * Contexts:
530 * ComplexObject returns NamedObject
531 * Object returns NamedObject
532 * NamedObject returns NamedObject
533 *
534 * Constraint:
535 * name=ID
536 */
537 protected void sequence_NamedObject(ISerializationContext context, NamedObject semanticObject) {
538 if (errorAcceptor != null) {
539 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME) == ValueTransient.YES)
540 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.NAMED_OBJECT__NAME));
541 }
542 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
543 feeder.accept(grammarAccess.getNamedObjectAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
544 feeder.finish();
545 }
546
547
548 /**
549 * Contexts:
550 * Parameter returns Parameter
551 *
552 * Constraint:
553 * (variable=Variable type=Symbol?)
554 */
555 protected void sequence_Parameter(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Parameter semanticObject) {
556 genericSequencer.createSequence(context, semanticObject);
557 }
558
559
560 /**
561 * Contexts:
562 * PatternBody returns PatternBody
563 *
564 * Constraint:
565 * constraints+=Constraint*
566 */
567 protected void sequence_PatternBody(ISerializationContext context, PatternBody semanticObject) {
568 genericSequencer.createSequence(context, semanticObject);
569 }
570
571
572 /**
573 * Contexts:
574 * Polarity returns Negative
575 *
576 * Constraint:
577 * {Negative}
578 */
579 protected void sequence_Polarity(ISerializationContext context, Negative semanticObject) {
580 genericSequencer.createSequence(context, semanticObject);
581 }
582
583
584 /**
585 * Contexts:
586 * Polarity returns Positive
587 *
588 * Constraint:
589 * {Positive}
590 */
591 protected void sequence_Polarity(ISerializationContext context, Positive semanticObject) {
592 genericSequencer.createSequence(context, semanticObject);
593 }
594
595
596 /**
597 * Contexts:
598 * Statement returns PredicateSymbol
599 * Predicate returns PredicateSymbol
600 * PredicateSymbol returns PredicateSymbol
601 *
602 * Constraint:
603 * (symbol=ModelSymbol parameters+=Parameter* (bodies+=PatternBody bodies+=PatternBody*)?)
604 */
605 protected void sequence_PredicateSymbol(ISerializationContext context, PredicateSymbol semanticObject) {
606 genericSequencer.createSequence(context, semanticObject);
607 }
608
609
610 /**
611 * Contexts:
612 * Problem returns Problem
613 *
614 * Constraint:
615 * statements+=Statement+
616 */
617 protected void sequence_Problem(ISerializationContext context, Problem semanticObject) {
618 genericSequencer.createSequence(context, semanticObject);
619 }
620
621
622 /**
623 * Contexts:
624 * ComplexObject returns RealObject
625 * Object returns RealObject
626 * DataObject returns RealObject
627 * RealObject returns RealObject
628 * Literal returns RealObject
629 *
630 * Constraint:
631 * value=REALLiteral
632 */
633 protected void sequence_RealObject(ISerializationContext context, RealObject semanticObject) {
634 if (errorAcceptor != null) {
635 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE) == ValueTransient.YES)
636 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.REAL_OBJECT__VALUE));
637 }
638 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
639 feeder.accept(grammarAccess.getRealObjectAccess().getValueREALLiteralParserRuleCall_0(), semanticObject.getValue());
640 feeder.finish();
641 }
642
643
644 /**
645 * Contexts:
646 * Symbol returns RealSymbol
647 * DataSymbol returns RealSymbol
648 * RealSymbol returns RealSymbol
649 *
650 * Constraint:
651 * {RealSymbol}
652 */
653 protected void sequence_RealSymbol(ISerializationContext context, RealSymbol semanticObject) {
654 genericSequencer.createSequence(context, semanticObject);
655 }
656
657
658 /**
659 * Contexts:
660 * ComplexObject returns StringObject
661 * Object returns StringObject
662 * DataObject returns StringObject
663 * StringObject returns StringObject
664 * Literal returns StringObject
665 *
666 * Constraint:
667 * value=STRING
668 */
669 protected void sequence_StringObject(ISerializationContext context, StringObject semanticObject) {
670 if (errorAcceptor != null) {
671 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE) == ValueTransient.YES)
672 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.STRING_OBJECT__VALUE));
673 }
674 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
675 feeder.accept(grammarAccess.getStringObjectAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
676 feeder.finish();
677 }
678
679
680 /**
681 * Contexts:
682 * Symbol returns StringSymbol
683 * DataSymbol returns StringSymbol
684 * StringSymbol returns StringSymbol
685 *
686 * Constraint:
687 * {StringSymbol}
688 */
689 protected void sequence_StringSymbol(ISerializationContext context, StringSymbol semanticObject) {
690 genericSequencer.createSequence(context, semanticObject);
691 }
692
693
694 /**
695 * Contexts:
696 * TruthValue returns Error
697 *
698 * Constraint:
699 * {Error}
700 */
701 protected void sequence_TruthValue(ISerializationContext context, org.eclipse.viatra.solver.language.solverLanguage.Error semanticObject) {
702 genericSequencer.createSequence(context, semanticObject);
703 }
704
705
706 /**
707 * Contexts:
708 * TruthValue returns False
709 *
710 * Constraint:
711 * {False}
712 */
713 protected void sequence_TruthValue(ISerializationContext context, False semanticObject) {
714 genericSequencer.createSequence(context, semanticObject);
715 }
716
717
718 /**
719 * Contexts:
720 * TruthValue returns True
721 *
722 * Constraint:
723 * {True}
724 */
725 protected void sequence_TruthValue(ISerializationContext context, True semanticObject) {
726 genericSequencer.createSequence(context, semanticObject);
727 }
728
729
730 /**
731 * Contexts:
732 * TruthValue returns Unknown
733 *
734 * Constraint:
735 * {Unknown}
736 */
737 protected void sequence_TruthValue(ISerializationContext context, Unknown semanticObject) {
738 genericSequencer.createSequence(context, semanticObject);
739 }
740
741
742 /**
743 * Contexts:
744 * ComplexObject returns UnnamedObject
745 * Object returns UnnamedObject
746 * UnnamedObject returns UnnamedObject
747 *
748 * Constraint:
749 * name=ID
750 */
751 protected void sequence_UnnamedObject(ISerializationContext context, UnnamedObject semanticObject) {
752 if (errorAcceptor != null) {
753 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME) == ValueTransient.YES)
754 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.UNNAMED_OBJECT__NAME));
755 }
756 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
757 feeder.accept(grammarAccess.getUnnamedObjectAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
758 feeder.finish();
759 }
760
761
762 /**
763 * Contexts:
764 * Literal returns Variable
765 * Variable returns Variable
766 *
767 * Constraint:
768 * name=ID
769 */
770 protected void sequence_Variable(ISerializationContext context, Variable semanticObject) {
771 if (errorAcceptor != null) {
772 if (transientValues.isValueTransient(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME) == ValueTransient.YES)
773 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, SolverLanguagePackage.Literals.VARIABLE__NAME));
774 }
775 SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
776 feeder.accept(grammarAccess.getVariableAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
777 feeder.finish();
778 }
779
780
781}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-07-19 18:38:25 +0000