Source code

001/*******************************************************************************
002 * Copyright (c) 2018 Red Hat Inc
003 * All rights reserved. This program and the accompanying materials
004 * are made available under the terms of the Eclipse Public License v1.0
005 * which accompanies this distribution, and is available at
006 * http://www.eclipse.org/legal/epl-v10.html
007 *
008 * Contributors:
009 *     Jens Reimann - initial API and implementation
010 *******************************************************************************/
011package de.dentrassi.varlink.idl.serializer;
012
013import com.google.inject.Inject;
014import de.dentrassi.varlink.idl.services.VarlinkIdlGrammarAccess;
015import de.dentrassi.varlink.idl.varlinkIdl.Arguments;
016import de.dentrassi.varlink.idl.varlinkIdl.Array;
017import de.dentrassi.varlink.idl.varlinkIdl.BasicType;
018import de.dentrassi.varlink.idl.varlinkIdl.Dictionary;
019import de.dentrassi.varlink.idl.varlinkIdl.Field;
020import de.dentrassi.varlink.idl.varlinkIdl.Interface;
021import de.dentrassi.varlink.idl.varlinkIdl.Method;
022import de.dentrassi.varlink.idl.varlinkIdl.Optional;
023import de.dentrassi.varlink.idl.varlinkIdl.Result;
024import de.dentrassi.varlink.idl.varlinkIdl.TypeAlias;
025import de.dentrassi.varlink.idl.varlinkIdl.TypeReference;
026import de.dentrassi.varlink.idl.varlinkIdl.VarlinkIdlPackage;
027import java.util.Set;
028import org.eclipse.emf.ecore.EObject;
029import org.eclipse.emf.ecore.EPackage;
030import org.eclipse.xtext.Action;
031import org.eclipse.xtext.Parameter;
032import org.eclipse.xtext.ParserRule;
033import org.eclipse.xtext.serializer.ISerializationContext;
034import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
035import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
036import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
037
038@SuppressWarnings("all")
039public class VarlinkIdlSemanticSequencer extends AbstractDelegatingSemanticSequencer {
040
041        @Inject
042        private VarlinkIdlGrammarAccess grammarAccess;
043        
044        @Override
045        public void sequence(ISerializationContext context, EObject semanticObject) {
046                EPackage epackage = semanticObject.eClass().getEPackage();
047                ParserRule rule = context.getParserRule();
048                Action action = context.getAssignedAction();
049                Set<Parameter> parameters = context.getEnabledBooleanParameters();
050                if (epackage == VarlinkIdlPackage.eINSTANCE)
051                        switch (semanticObject.eClass().getClassifierID()) {
052                        case VarlinkIdlPackage.ARGUMENTS:
053                                sequence_Arguments(context, (Arguments) semanticObject); 
054                                return; 
055                        case VarlinkIdlPackage.ARRAY:
056                                sequence_Array(context, (Array) semanticObject); 
057                                return; 
058                        case VarlinkIdlPackage.BASIC_TYPE:
059                                sequence_BasicType(context, (BasicType) semanticObject); 
060                                return; 
061                        case VarlinkIdlPackage.DICTIONARY:
062                                sequence_Dictionary(context, (Dictionary) semanticObject); 
063                                return; 
064                        case VarlinkIdlPackage.ENUM:
065                                sequence_Enum(context, (de.dentrassi.varlink.idl.varlinkIdl.Enum) semanticObject); 
066                                return; 
067                        case VarlinkIdlPackage.ERROR:
068                                sequence_Error(context, (de.dentrassi.varlink.idl.varlinkIdl.Error) semanticObject); 
069                                return; 
070                        case VarlinkIdlPackage.FIELD:
071                                sequence_Field(context, (Field) semanticObject); 
072                                return; 
073                        case VarlinkIdlPackage.INTERFACE:
074                                sequence_Interface(context, (Interface) semanticObject); 
075                                return; 
076                        case VarlinkIdlPackage.METHOD:
077                                sequence_Method(context, (Method) semanticObject); 
078                                return; 
079                        case VarlinkIdlPackage.OBJECT:
080                                sequence_Object(context, (de.dentrassi.varlink.idl.varlinkIdl.Object) semanticObject); 
081                                return; 
082                        case VarlinkIdlPackage.OPTIONAL:
083                                sequence_Optional(context, (Optional) semanticObject); 
084                                return; 
085                        case VarlinkIdlPackage.RESULT:
086                                sequence_Result(context, (Result) semanticObject); 
087                                return; 
088                        case VarlinkIdlPackage.TYPE_ALIAS:
089                                sequence_TypeAlias(context, (TypeAlias) semanticObject); 
090                                return; 
091                        case VarlinkIdlPackage.TYPE_REFERENCE:
092                                sequence_TypeReference(context, (TypeReference) semanticObject); 
093                                return; 
094                        }
095                if (errorAcceptor != null)
096                        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
097        }
098        
099        /**
100         * Contexts:
101         *     Arguments returns Arguments
102         *
103         * Constraint:
104         *     arguments=Object
105         */
106        protected void sequence_Arguments(ISerializationContext context, Arguments semanticObject) {
107                if (errorAcceptor != null) {
108                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.ARGUMENTS__ARGUMENTS) == ValueTransient.YES)
109                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.ARGUMENTS__ARGUMENTS));
110                }
111                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
112                feeder.accept(grammarAccess.getArgumentsAccess().getArgumentsObjectParserRuleCall_0(), semanticObject.getArguments());
113                feeder.finish();
114        }
115        
116        
117        /**
118         * Contexts:
119         *     ElementType returns Array
120         *     Array returns Array
121         *
122         * Constraint:
123         *     type=ElementType
124         */
125        protected void sequence_Array(ISerializationContext context, Array semanticObject) {
126                if (errorAcceptor != null) {
127                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.ARRAY__TYPE) == ValueTransient.YES)
128                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.ARRAY__TYPE));
129                }
130                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
131                feeder.accept(grammarAccess.getArrayAccess().getTypeElementTypeParserRuleCall_1_0(), semanticObject.getType());
132                feeder.finish();
133        }
134        
135        
136        /**
137         * Contexts:
138         *     ElementType returns BasicType
139         *     BasicType returns BasicType
140         *
141         * Constraint:
142         *     (type='bool' | type='int' | type='float' | type='string')
143         */
144        protected void sequence_BasicType(ISerializationContext context, BasicType semanticObject) {
145                genericSequencer.createSequence(context, semanticObject);
146        }
147        
148        
149        /**
150         * Contexts:
151         *     ElementType returns Dictionary
152         *     Dictionary returns Dictionary
153         *
154         * Constraint:
155         *     type=ElementType
156         */
157        protected void sequence_Dictionary(ISerializationContext context, Dictionary semanticObject) {
158                if (errorAcceptor != null) {
159                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.DICTIONARY__TYPE) == ValueTransient.YES)
160                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.DICTIONARY__TYPE));
161                }
162                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
163                feeder.accept(grammarAccess.getDictionaryAccess().getTypeElementTypeParserRuleCall_1_0(), semanticObject.getType());
164                feeder.finish();
165        }
166        
167        
168        /**
169         * Contexts:
170         *     TypeAliasDefinition returns Enum
171         *     Enum returns Enum
172         *     ElementType returns Enum
173         *
174         * Constraint:
175         *     (fields+=ValidID fields+=ValidID*)
176         */
177        protected void sequence_Enum(ISerializationContext context, de.dentrassi.varlink.idl.varlinkIdl.Enum semanticObject) {
178                genericSequencer.createSequence(context, semanticObject);
179        }
180        
181        
182        /**
183         * Contexts:
184         *     Member returns Error
185         *     Error returns Error
186         *
187         * Constraint:
188         *     (name=ID properties=Object)
189         */
190        protected void sequence_Error(ISerializationContext context, de.dentrassi.varlink.idl.varlinkIdl.Error semanticObject) {
191                if (errorAcceptor != null) {
192                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME) == ValueTransient.YES)
193                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME));
194                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.ERROR__PROPERTIES) == ValueTransient.YES)
195                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.ERROR__PROPERTIES));
196                }
197                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
198                feeder.accept(grammarAccess.getErrorAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
199                feeder.accept(grammarAccess.getErrorAccess().getPropertiesObjectParserRuleCall_2_0(), semanticObject.getProperties());
200                feeder.finish();
201        }
202        
203        
204        /**
205         * Contexts:
206         *     Field returns Field
207         *
208         * Constraint:
209         *     (name=ValidID type=ElementType)
210         */
211        protected void sequence_Field(ISerializationContext context, Field semanticObject) {
212                if (errorAcceptor != null) {
213                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.FIELD__NAME) == ValueTransient.YES)
214                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.FIELD__NAME));
215                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.FIELD__TYPE) == ValueTransient.YES)
216                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.FIELD__TYPE));
217                }
218                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
219                feeder.accept(grammarAccess.getFieldAccess().getNameValidIDParserRuleCall_0_0(), semanticObject.getName());
220                feeder.accept(grammarAccess.getFieldAccess().getTypeElementTypeParserRuleCall_2_0(), semanticObject.getType());
221                feeder.finish();
222        }
223        
224        
225        /**
226         * Contexts:
227         *     Interface returns Interface
228         *
229         * Constraint:
230         *     (name=InterfaceName members+=Member*)
231         */
232        protected void sequence_Interface(ISerializationContext context, Interface semanticObject) {
233                genericSequencer.createSequence(context, semanticObject);
234        }
235        
236        
237        /**
238         * Contexts:
239         *     Member returns Method
240         *     Method returns Method
241         *
242         * Constraint:
243         *     (name=ID arguments=Arguments result=Result)
244         */
245        protected void sequence_Method(ISerializationContext context, Method semanticObject) {
246                if (errorAcceptor != null) {
247                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME) == ValueTransient.YES)
248                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME));
249                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.METHOD__ARGUMENTS) == ValueTransient.YES)
250                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.METHOD__ARGUMENTS));
251                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.METHOD__RESULT) == ValueTransient.YES)
252                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.METHOD__RESULT));
253                }
254                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
255                feeder.accept(grammarAccess.getMethodAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
256                feeder.accept(grammarAccess.getMethodAccess().getArgumentsArgumentsParserRuleCall_2_0(), semanticObject.getArguments());
257                feeder.accept(grammarAccess.getMethodAccess().getResultResultParserRuleCall_4_0(), semanticObject.getResult());
258                feeder.finish();
259        }
260        
261        
262        /**
263         * Contexts:
264         *     TypeAliasDefinition returns Object
265         *     Object returns Object
266         *     ElementType returns Object
267         *
268         * Constraint:
269         *     (fields+=Field? fields+=Field*)
270         */
271        protected void sequence_Object(ISerializationContext context, de.dentrassi.varlink.idl.varlinkIdl.Object semanticObject) {
272                genericSequencer.createSequence(context, semanticObject);
273        }
274        
275        
276        /**
277         * Contexts:
278         *     ElementType returns Optional
279         *     Optional returns Optional
280         *
281         * Constraint:
282         *     type=ElementType
283         */
284        protected void sequence_Optional(ISerializationContext context, Optional semanticObject) {
285                if (errorAcceptor != null) {
286                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.OPTIONAL__TYPE) == ValueTransient.YES)
287                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.OPTIONAL__TYPE));
288                }
289                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
290                feeder.accept(grammarAccess.getOptionalAccess().getTypeElementTypeParserRuleCall_1_0(), semanticObject.getType());
291                feeder.finish();
292        }
293        
294        
295        /**
296         * Contexts:
297         *     Result returns Result
298         *
299         * Constraint:
300         *     result=Object
301         */
302        protected void sequence_Result(ISerializationContext context, Result semanticObject) {
303                if (errorAcceptor != null) {
304                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.RESULT__RESULT) == ValueTransient.YES)
305                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.RESULT__RESULT));
306                }
307                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
308                feeder.accept(grammarAccess.getResultAccess().getResultObjectParserRuleCall_0(), semanticObject.getResult());
309                feeder.finish();
310        }
311        
312        
313        /**
314         * Contexts:
315         *     Member returns TypeAlias
316         *     TypeAlias returns TypeAlias
317         *
318         * Constraint:
319         *     (name=ValidID definition=TypeAliasDefinition)
320         */
321        protected void sequence_TypeAlias(ISerializationContext context, TypeAlias semanticObject) {
322                if (errorAcceptor != null) {
323                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME) == ValueTransient.YES)
324                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.MEMBER__NAME));
325                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.TYPE_ALIAS__DEFINITION) == ValueTransient.YES)
326                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.TYPE_ALIAS__DEFINITION));
327                }
328                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
329                feeder.accept(grammarAccess.getTypeAliasAccess().getNameValidIDParserRuleCall_1_0(), semanticObject.getName());
330                feeder.accept(grammarAccess.getTypeAliasAccess().getDefinitionTypeAliasDefinitionParserRuleCall_2_0(), semanticObject.getDefinition());
331                feeder.finish();
332        }
333        
334        
335        /**
336         * Contexts:
337         *     ElementType returns TypeReference
338         *     TypeReference returns TypeReference
339         *
340         * Constraint:
341         *     name=[TypeAlias|ID]
342         */
343        protected void sequence_TypeReference(ISerializationContext context, TypeReference semanticObject) {
344                if (errorAcceptor != null) {
345                        if (transientValues.isValueTransient(semanticObject, VarlinkIdlPackage.Literals.TYPE_REFERENCE__NAME) == ValueTransient.YES)
346                                errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, VarlinkIdlPackage.Literals.TYPE_REFERENCE__NAME));
347                }
348                SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
349                feeder.accept(grammarAccess.getTypeReferenceAccess().getNameTypeAliasIDTerminalRuleCall_0_1(), semanticObject.eGet(VarlinkIdlPackage.Literals.TYPE_REFERENCE__NAME, false));
350                feeder.finish();
351        }
352        
353        
354}