1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
|
package org.eclipse.etrice.core.etphys.serializer;
import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.etrice.core.etphys.eTPhys.Documentation;
import org.eclipse.etrice.core.etphys.eTPhys.ETPhysPackage;
import org.eclipse.etrice.core.etphys.eTPhys.Import;
import org.eclipse.etrice.core.etphys.eTPhys.NodeClass;
import org.eclipse.etrice.core.etphys.eTPhys.NodeRef;
import org.eclipse.etrice.core.etphys.eTPhys.PhysicalModel;
import org.eclipse.etrice.core.etphys.eTPhys.PhysicalSystem;
import org.eclipse.etrice.core.etphys.eTPhys.PhysicalThread;
import org.eclipse.etrice.core.etphys.eTPhys.RuntimeClass;
import org.eclipse.etrice.core.etphys.services.ETPhysGrammarAccess;
import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
@SuppressWarnings("all")
public class ETPhysSemanticSequencer extends AbstractDelegatingSemanticSequencer {
@Inject
private ETPhysGrammarAccess grammarAccess;
public void createSequence(EObject context, EObject semanticObject) {
if(semanticObject.eClass().getEPackage() == ETPhysPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
case ETPhysPackage.DOCUMENTATION:
if(context == grammarAccess.getDocumentationRule()) {
sequence_Documentation(context, (Documentation) semanticObject);
return;
}
else break;
case ETPhysPackage.IMPORT:
if(context == grammarAccess.getImportRule()) {
sequence_Import(context, (Import) semanticObject);
return;
}
else break;
case ETPhysPackage.NODE_CLASS:
if(context == grammarAccess.getNodeClassRule()) {
sequence_NodeClass(context, (NodeClass) semanticObject);
return;
}
else break;
case ETPhysPackage.NODE_REF:
if(context == grammarAccess.getNodeRefRule()) {
sequence_NodeRef(context, (NodeRef) semanticObject);
return;
}
else break;
case ETPhysPackage.PHYSICAL_MODEL:
if(context == grammarAccess.getPhysicalModelRule()) {
sequence_PhysicalModel(context, (PhysicalModel) semanticObject);
return;
}
else break;
case ETPhysPackage.PHYSICAL_SYSTEM:
if(context == grammarAccess.getPhysicalSystemRule()) {
sequence_PhysicalSystem(context, (PhysicalSystem) semanticObject);
return;
}
else break;
case ETPhysPackage.PHYSICAL_THREAD:
if(context == grammarAccess.getPhysicalThreadRule()) {
sequence_PhysicalThread(context, (PhysicalThread) semanticObject);
return;
}
else break;
case ETPhysPackage.RUNTIME_CLASS:
if(context == grammarAccess.getRuntimeClassRule()) {
sequence_RuntimeClass(context, (RuntimeClass) semanticObject);
return;
}
else break;
}
if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}
/**
* Constraint:
* text+=STRING+
*/
protected void sequence_Documentation(EObject context, Documentation semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (importedNamespace=ImportedFQN? importURI=STRING)
*/
protected void sequence_Import(EObject context, Import semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (
* name=ID
* docu=Documentation?
* runtime=[RuntimeClass|FQN]
* priomin=PRIO
* priomax=PRIO
* threads+=PhysicalThread*
* )
*/
protected void sequence_NodeClass(EObject context, NodeClass semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (name=ID type=[NodeClass|FQN] docu=Documentation?)
*/
protected void sequence_NodeRef(EObject context, NodeRef semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (name=FQN imports+=Import* (systems+=PhysicalSystem | nodeClasses+=NodeClass | runtimeClasses+=RuntimeClass)*)
*/
protected void sequence_PhysicalModel(EObject context, PhysicalModel semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (name=ID docu=Documentation? nodeRefs+=NodeRef*)
*/
protected void sequence_PhysicalSystem(EObject context, PhysicalSystem semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (
* default?='DefaultThread'?
* name=ID
* execmode=ExecMode
* prio=PRIO
* stacksize=INT
* msgblocksize=INT
* msgpoolsize=INT
* )
*/
protected void sequence_PhysicalThread(EObject context, PhysicalThread semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
/**
* Constraint:
* (name=ID docu=Documentation? threadModel=ThreadModel)
*/
protected void sequence_RuntimeClass(EObject context, RuntimeClass semanticObject) {
genericSequencer.createSequence(context, semanticObject);
}
}
|
