nemo-tools/eclipse-plugin/nemo-editor/org.opendaylight.nemo.tool.eclipse.plugin.editor/src-gen/org/opendaylight/nemo/tool/eclipse/plugin/serializer/EditorSemanticSequencer.java

   1 /*
   2  * generated by Xtext
   3  */
   4 package org.opendaylight.nemo.tool.eclipse.plugin.serializer;
   5
   6 import com.google.inject.Inject;
   7 import com.google.inject.Provider;
   8 import org.eclipse.emf.ecore.EObject;
   9 import org.eclipse.xtext.serializer.acceptor.ISemanticSequenceAcceptor;
  10 import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
  11 import org.eclipse.xtext.serializer.diagnostic.ISemanticSequencerDiagnosticProvider;
  12 import org.eclipse.xtext.serializer.diagnostic.ISerializationDiagnostic.Acceptor;
  13 import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
  14 import org.eclipse.xtext.serializer.sequencer.GenericSequencer;
  15 import org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider;
  16 import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
  17 import org.eclipse.xtext.serializer.sequencer.ITransientValueService;
  18 import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
  19 import org.opendaylight.nemo.tool.eclipse.plugin.editor.Connection;
  20 import org.opendaylight.nemo.tool.eclipse.plugin.editor.ConnectionUpdate;
  21 import org.opendaylight.nemo.tool.eclipse.plugin.editor.EditorPackage;
  22 import org.opendaylight.nemo.tool.eclipse.plugin.editor.Flow;
  23 import org.opendaylight.nemo.tool.eclipse.plugin.editor.FlowUpdate;
  24 import org.opendaylight.nemo.tool.eclipse.plugin.editor.Model;
  25 import org.opendaylight.nemo.tool.eclipse.plugin.editor.Node;
  26 import org.opendaylight.nemo.tool.eclipse.plugin.editor.NodeModel;
  27 import org.opendaylight.nemo.tool.eclipse.plugin.editor.NodeOperating;
  28 import org.opendaylight.nemo.tool.eclipse.plugin.editor.Operation;
  29 import org.opendaylight.nemo.tool.eclipse.plugin.services.EditorGrammarAccess;
  30
  31 @SuppressWarnings("all")
  32 public class EditorSemanticSequencer extends AbstractDelegatingSemanticSequencer {
  33
  34         @Inject
  35         private EditorGrammarAccess grammarAccess;
  36
  37         @Override
  38         public void createSequence(EObject context, EObject semanticObject) {
  39                 if(semanticObject.eClass().getEPackage() == EditorPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
  40                         case EditorPackage.CONNECTION:
  41                                 sequence_Connection(context, (Connection) semanticObject);
  42                                 return;
  43                         case EditorPackage.CONNECTION_UPDATE:
  44                                 sequence_ConnectionUpdate(context, (ConnectionUpdate) semanticObject);
  45                                 return;
  46                         case EditorPackage.FLOW:
  47                                 sequence_Flow(context, (Flow) semanticObject);
  48                                 return;
  49                         case EditorPackage.FLOW_UPDATE:
  50                                 sequence_FlowUpdate(context, (FlowUpdate) semanticObject);
  51                                 return;
  52                         case EditorPackage.MODEL:
  53                                 sequence_Model(context, (Model) semanticObject);
  54                                 return;
  55                         case EditorPackage.NODE:
  56                                 sequence_Node(context, (Node) semanticObject);
  57                                 return;
  58                         case EditorPackage.NODE_MODEL:
  59                                 sequence_NodeModel(context, (NodeModel) semanticObject);
  60                                 return;
  61                         case EditorPackage.NODE_OPERATING:
  62                                 sequence_NodeOperating(context, (NodeOperating) semanticObject);
  63                                 return;
  64                         case EditorPackage.OPERATION:
  65                                 sequence_Operation(context, (Operation) semanticObject);
  66                                 return;
  67                         }
  68                 if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
  69         }
  70
  71         /**
  72          * Constraint:
  73          *     (connectionname+=[Connection|NemoId] (endnode+=[Node|NemoId] endnode+=[Node|NemoId]*)?)
  74          */
  75         protected void sequence_ConnectionUpdate(EObject context, ConnectionUpdate semanticObject) {
  76                 genericSequencer.createSequence(context, semanticObject);
  77         }
  78
  79
  80         /**
  81          * Constraint:
  82          *     (name=NemoId endnode+=[Node|NemoId] endnode+=[Node|NemoId]*)
  83          */
  84         protected void sequence_Connection(EObject context, Connection semanticObject) {
  85                 genericSequencer.createSequence(context, semanticObject);
  86         }
  87
  88
  89         /**
  90          * Constraint:
  91          *     flowId+=[Flow|NemoId]
  92          */
  93         protected void sequence_FlowUpdate(EObject context, FlowUpdate semanticObject) {
  94                 genericSequencer.createSequence(context, semanticObject);
  95         }
  96
  97
  98         /**
  99          * Constraint:
 100          *     name=NemoId
 101          */
 102         protected void sequence_Flow(EObject context, Flow semanticObject) {
 103                 if(errorAcceptor != null) {
 104                         if(transientValues.isValueTransient(semanticObject, EditorPackage.Literals.FLOW__NAME) == ValueTransient.YES)
 105                                 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, EditorPackage.Literals.FLOW__NAME));
 106                 }
 107                 INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
 108                 SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
 109                 feeder.accept(grammarAccess.getFlowAccess().getNameNemoIdTerminalRuleCall_2_0(), semanticObject.getName());
 110                 feeder.finish();
 111         }
 112
 113
 114         /**
 115          * Constraint:
 116          *     sentences+=Sentence*
 117          */
 118         protected void sequence_Model(EObject context, Model semanticObject) {
 119                 genericSequencer.createSequence(context, semanticObject);
 120         }
 121
 122
 123         /**
 124          * Constraint:
 125          *     name=NemoId
 126          */
 127         protected void sequence_NodeModel(EObject context, NodeModel semanticObject) {
 128                 if(errorAcceptor != null) {
 129                         if(transientValues.isValueTransient(semanticObject, EditorPackage.Literals.NODE_MODEL__NAME) == ValueTransient.YES)
 130                                 errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, EditorPackage.Literals.NODE_MODEL__NAME));
 131                 }
 132                 INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
 133                 SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
 134                 feeder.accept(grammarAccess.getNodeModelAccess().getNameNemoIdTerminalRuleCall_1_0(), semanticObject.getName());
 135                 feeder.finish();
 136         }
 137
 138
 139         /**
 140          * Constraint:
 141          *     (nodename+=[Node|NemoId] (nodes+=[Node|NemoId] nodes+=[Node|NemoId]*)?)
 142          */
 143         protected void sequence_NodeOperating(EObject context, NodeOperating semanticObject) {
 144                 genericSequencer.createSequence(context, semanticObject);
 145         }
 146
 147
 148         /**
 149          * Constraint:
 150          *     (name=NemoId (nodes+=[Node|NemoId] nodes+=[Node|NemoId]*)?)
 151          */
 152         protected void sequence_Node(EObject context, Node semanticObject) {
 153                 genericSequencer.createSequence(context, semanticObject);
 154         }
 155
 156
 157         /**
 158          * Constraint:
 159          *     (name=NemoId value+=INT? targetId=[Flow|NemoId] targetNode=[Node|NemoId]?)
 160          */
 161         protected void sequence_Operation(EObject context, Operation semanticObject) {
 162                 genericSequencer.createSequence(context, semanticObject);
 163         }
 164 }