QVTOperationalSemanticSequencer.java

/*
 * generated by Xtext
 */
package org.eclipse.qvto.examples.xtext.qvtoperational.serializer;

import com.google.inject.Inject;
import com.google.inject.Provider;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.ocl.xtext.basecs.BaseCSPackage;
import org.eclipse.ocl.xtext.basecs.DataTypeCS;
import org.eclipse.ocl.xtext.basecs.EnumerationCS;
import org.eclipse.ocl.xtext.basecs.EnumerationLiteralCS;
import org.eclipse.ocl.xtext.basecs.MultiplicityBoundsCS;
import org.eclipse.ocl.xtext.basecs.MultiplicityStringCS;
import org.eclipse.ocl.xtext.basecs.ParameterCS;
import org.eclipse.ocl.xtext.basecs.PathElementCS;
import org.eclipse.ocl.xtext.basecs.PathElementWithURICS;
import org.eclipse.ocl.xtext.basecs.PathNameCS;
import org.eclipse.ocl.xtext.basecs.PrimitiveTypeRefCS;
import org.eclipse.ocl.xtext.basecs.StructuredClassCS;
import org.eclipse.ocl.xtext.basecs.TemplateBindingCS;
import org.eclipse.ocl.xtext.basecs.TemplateParameterSubstitutionCS;
import org.eclipse.ocl.xtext.basecs.TemplateSignatureCS;
import org.eclipse.ocl.xtext.basecs.TuplePartCS;
import org.eclipse.ocl.xtext.basecs.TupleTypeCS;
import org.eclipse.ocl.xtext.basecs.TypeParameterCS;
import org.eclipse.ocl.xtext.basecs.TypedTypeRefCS;
import org.eclipse.ocl.xtext.basecs.WildcardTypeRefCS;
import org.eclipse.ocl.xtext.essentialoclcs.BooleanLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.CollectionLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.CollectionLiteralPartCS;
import org.eclipse.ocl.xtext.essentialoclcs.CollectionPatternCS;
import org.eclipse.ocl.xtext.essentialoclcs.CollectionTypeCS;
import org.eclipse.ocl.xtext.essentialoclcs.ContextCS;
import org.eclipse.ocl.xtext.essentialoclcs.CurlyBracketedClauseCS;
import org.eclipse.ocl.xtext.essentialoclcs.EssentialOCLCSPackage;
import org.eclipse.ocl.xtext.essentialoclcs.IfExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.IfThenExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.InfixExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.InvalidLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.LambdaLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.LetExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.LetVariableCS;
import org.eclipse.ocl.xtext.essentialoclcs.MapLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.MapLiteralPartCS;
import org.eclipse.ocl.xtext.essentialoclcs.MapTypeCS;
import org.eclipse.ocl.xtext.essentialoclcs.NameExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.NavigatingArgCS;
import org.eclipse.ocl.xtext.essentialoclcs.NestedExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.NullLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.NumberLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.PatternExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.PrefixExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.RoundBracketedClauseCS;
import org.eclipse.ocl.xtext.essentialoclcs.SelfExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.ShadowPartCS;
import org.eclipse.ocl.xtext.essentialoclcs.SquareBracketedClauseCS;
import org.eclipse.ocl.xtext.essentialoclcs.StringLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.TupleLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.TupleLiteralPartCS;
import org.eclipse.ocl.xtext.essentialoclcs.TypeLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.TypeNameExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.UnlimitedNaturalLiteralExpCS;
import org.eclipse.ocl.xtext.essentialoclcs.VariableCS;
import org.eclipse.qvto.examples.xtext.imperativeocl.serializer.ImperativeOCLSemanticSequencer;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.AssertExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.AssignExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.BreakExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.CatchExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ComputeExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ContinueExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.DictLiteralExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.DictLiteralPartCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.DictTypeCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ExpressionBlockCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ExtentRefCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ForExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ImperativeIterateExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ImperativeOCLCSPackage;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.InstantiationExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ListLiteralExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ListTypeCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.LogExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.RaiseExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.ReturnExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.SwitchAltCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.SwitchExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.TryExpCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.VarDeclarationCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.VarsInitializationCS;
import org.eclipse.qvto.examples.xtext.imperativeoclcs.WhileExpCS;
import org.eclipse.qvto.examples.xtext.qvtoperational.services.QVTOperationalGrammarAccess;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ClassifierPropertyCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ConfigurationPropertyCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ConstructorOperationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ContextualPropertyCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.EntryOperationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.HelperOperationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.InitPartCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.MappingBodyCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.MappingCallExpCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.MappingOperationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.MetamodelCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ModelTypeCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ModelTypeRefCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ModuleRefCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ModuleUsageCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ObjectExpCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.OperationBodyCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.OperationRefCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.PackageRefCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ParameterDeclarationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.PathElement2CS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.PathName2CS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.PrimitiveTypeCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.QVTOperationalCSPackage;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.QVToClassCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.QVToImportCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.QVToLibraryCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.QVToOperationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ResolveByMappingExpCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.ResolveByTypeExpCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.StereotypeQualifierCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.TagCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.TopLevelCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.TransformationCS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.TypedTypeRef2CS;
import org.eclipse.qvto.examples.xtext.qvtoperationalcs.UnitRefCS;
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.GenericSequencer;
import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService;

@SuppressWarnings("all")
public class QVTOperationalSemanticSequencer extends ImperativeOCLSemanticSequencer {

	@Inject
	private QVTOperationalGrammarAccess grammarAccess;
	
	@Override
	public void createSequence(EObject context, EObject semanticObject) {
		if(semanticObject.eClass().getEPackage() == BaseCSPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case BaseCSPackage.DATA_TYPE_CS:
				sequence_DataTypeCS(context, (DataTypeCS) semanticObject); 
				return; 
			case BaseCSPackage.ENUMERATION_CS:
				sequence_EnumerationCS(context, (EnumerationCS) semanticObject); 
				return; 
			case BaseCSPackage.ENUMERATION_LITERAL_CS:
				sequence_EnumerationLiteralCS(context, (EnumerationLiteralCS) semanticObject); 
				return; 
			case BaseCSPackage.MULTIPLICITY_BOUNDS_CS:
				if(context == grammarAccess.getMultiplicityBoundsCSRule()) {
					sequence_MultiplicityBoundsCS(context, (MultiplicityBoundsCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getMultiplicityCSRule()) {
					sequence_MultiplicityCS(context, (MultiplicityBoundsCS) semanticObject); 
					return; 
				}
				else break;
			case BaseCSPackage.MULTIPLICITY_STRING_CS:
				sequence_MultiplicityStringCS(context, (MultiplicityStringCS) semanticObject); 
				return; 
			case BaseCSPackage.PARAMETER_CS:
				sequence_ParameterCS(context, (ParameterCS) semanticObject); 
				return; 
			case BaseCSPackage.PATH_ELEMENT_CS:
				if(context == grammarAccess.getFirstPathElementCSRule()) {
					sequence_FirstPathElementCS(context, (PathElementCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getNextPathElementCSRule()) {
					sequence_NextPathElementCS(context, (PathElementCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getURIFirstPathElementCSRule()) {
					sequence_URIFirstPathElementCS(context, (PathElementCS) semanticObject); 
					return; 
				}
				else break;
			case BaseCSPackage.PATH_ELEMENT_WITH_URICS:
				sequence_URIFirstPathElementCS(context, (PathElementWithURICS) semanticObject); 
				return; 
			case BaseCSPackage.PATH_NAME_CS:
				if(context == grammarAccess.getPathNameCSRule()) {
					sequence_PathNameCS(context, (PathNameCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getURIPathNameCSRule()) {
					sequence_URIPathNameCS(context, (PathNameCS) semanticObject); 
					return; 
				}
				else break;
			case BaseCSPackage.PRIMITIVE_TYPE_REF_CS:
				if(context == grammarAccess.getPrimitiveTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_PrimitiveTypeCS(context, (PrimitiveTypeRefCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_PrimitiveTypeCS_TypeExpCS(context, (PrimitiveTypeRefCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_PrimitiveTypeCS_TypeLiteralWithMultiplicityCS(context, (PrimitiveTypeRefCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_PrimitiveTypeCS_TypedMultiplicityRef2CS(context, (PrimitiveTypeRefCS) semanticObject); 
					return; 
				}
				else break;
			case BaseCSPackage.STRUCTURED_CLASS_CS:
				sequence_ExceptionCS(context, (StructuredClassCS) semanticObject); 
				return; 
			case BaseCSPackage.TEMPLATE_BINDING_CS:
				sequence_TemplateBindingCS(context, (TemplateBindingCS) semanticObject); 
				return; 
			case BaseCSPackage.TEMPLATE_PARAMETER_SUBSTITUTION_CS:
				sequence_TemplateParameterSubstitutionCS(context, (TemplateParameterSubstitutionCS) semanticObject); 
				return; 
			case BaseCSPackage.TEMPLATE_SIGNATURE_CS:
				sequence_TemplateSignatureCS(context, (TemplateSignatureCS) semanticObject); 
				return; 
			case BaseCSPackage.TUPLE_PART_CS:
				sequence_TuplePartCS(context, (TuplePartCS) semanticObject); 
				return; 
			case BaseCSPackage.TUPLE_TYPE_CS:
				if(context == grammarAccess.getTupleTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_TupleTypeCS(context, (TupleTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_TupleTypeCS_TypeExpCS(context, (TupleTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_TupleTypeCS_TypeLiteralWithMultiplicityCS(context, (TupleTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_TupleTypeCS_TypedMultiplicityRef2CS(context, (TupleTypeCS) semanticObject); 
					return; 
				}
				else break;
			case BaseCSPackage.TYPE_PARAMETER_CS:
				sequence_TypeParameterCS(context, (TypeParameterCS) semanticObject); 
				return; 
			case BaseCSPackage.TYPED_TYPE_REF_CS:
				sequence_TypedTypeRefCS(context, (TypedTypeRefCS) semanticObject); 
				return; 
			case BaseCSPackage.WILDCARD_TYPE_REF_CS:
				sequence_WildcardTypeRefCS(context, (WildcardTypeRefCS) semanticObject); 
				return; 
			}
		else if(semanticObject.eClass().getEPackage() == EssentialOCLCSPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case EssentialOCLCSPackage.BOOLEAN_LITERAL_EXP_CS:
				sequence_BooleanLiteralExpCS(context, (BooleanLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.COLLECTION_LITERAL_EXP_CS:
				sequence_CollectionLiteralExpCS(context, (CollectionLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.COLLECTION_LITERAL_PART_CS:
				sequence_CollectionLiteralPartCS(context, (CollectionLiteralPartCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.COLLECTION_PATTERN_CS:
				if(context == grammarAccess.getCollectionPatternCSRule()) {
					sequence_CollectionPatternCS(context, (CollectionPatternCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_CollectionPatternCS_TypeExpCS(context, (CollectionPatternCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.COLLECTION_TYPE_CS:
				if(context == grammarAccess.getCollectionTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_CollectionTypeCS(context, (CollectionTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_CollectionTypeCS_TypeExpCS(context, (CollectionTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_CollectionTypeCS_TypeLiteralWithMultiplicityCS(context, (CollectionTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_CollectionTypeCS_TypedMultiplicityRef2CS(context, (CollectionTypeCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.CONTEXT_CS:
				sequence_Model(context, (ContextCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.CURLY_BRACKETED_CLAUSE_CS:
				sequence_CurlyBracketedClauseCS(context, (CurlyBracketedClauseCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.IF_EXP_CS:
				sequence_IfExpCS(context, (IfExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.IF_THEN_EXP_CS:
				sequence_ElseIfThenExpCS(context, (IfThenExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.INFIX_EXP_CS:
				sequence_ExpCS(context, (InfixExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.INVALID_LITERAL_EXP_CS:
				sequence_InvalidLiteralExpCS(context, (InvalidLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.LAMBDA_LITERAL_EXP_CS:
				sequence_LambdaLiteralExpCS(context, (LambdaLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.LET_EXP_CS:
				sequence_LetExpCS(context, (LetExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.LET_VARIABLE_CS:
				sequence_LetVariableCS(context, (LetVariableCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.MAP_LITERAL_EXP_CS:
				sequence_MapLiteralExpCS(context, (MapLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.MAP_LITERAL_PART_CS:
				sequence_MapLiteralPartCS(context, (MapLiteralPartCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.MAP_TYPE_CS:
				if(context == grammarAccess.getMapTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_MapTypeCS(context, (MapTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_MapTypeCS_TypeExpCS(context, (MapTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_MapTypeCS_TypeLiteralWithMultiplicityCS(context, (MapTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_MapTypeCS_TypedMultiplicityRef2CS(context, (MapTypeCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.NAME_EXP_CS:
				sequence_NameExpCS(context, (NameExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.NAVIGATING_ARG_CS:
				if(context == grammarAccess.getNavigatingArgCSRule()) {
					sequence_NavigatingArgCS(context, (NavigatingArgCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getNavigatingBarArgCSRule()) {
					sequence_NavigatingBarArgCS(context, (NavigatingArgCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getNavigatingCommaArgCSRule()) {
					sequence_NavigatingCommaArgCS(context, (NavigatingArgCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getNavigatingSemiArgCSRule()) {
					sequence_NavigatingSemiArgCS(context, (NavigatingArgCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.NESTED_EXP_CS:
				sequence_NestedExpCS(context, (NestedExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.NULL_LITERAL_EXP_CS:
				sequence_NullLiteralExpCS(context, (NullLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.NUMBER_LITERAL_EXP_CS:
				sequence_NumberLiteralExpCS(context, (NumberLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.PATTERN_EXP_CS:
				sequence_PatternExpCS(context, (PatternExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.PREFIX_EXP_CS:
				if(context == grammarAccess.getPrefixedLetExpCSRule()) {
					sequence_PrefixedLetExpCS(context, (PrefixExpCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getExpCSRule() ||
				   context == grammarAccess.getExpressionStatementCSRule() ||
				   context == grammarAccess.getGrammmarCSRule() ||
				   context == grammarAccess.getImperativeOCLExpCSRule() ||
				   context == grammarAccess.getNavigatingArgExpCSRule()) {
					sequence_PrefixedLetExpCS_PrefixedPrimaryExpCS(context, (PrefixExpCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0() ||
				   context == grammarAccess.getPrefixedPrimaryExpCSRule()) {
					sequence_PrefixedPrimaryExpCS(context, (PrefixExpCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.ROUND_BRACKETED_CLAUSE_CS:
				sequence_RoundBracketedClauseCS(context, (RoundBracketedClauseCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.SELF_EXP_CS:
				sequence_SelfExpCS(context, (SelfExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.SHADOW_PART_CS:
				sequence_ShadowPartCS(context, (ShadowPartCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.SQUARE_BRACKETED_CLAUSE_CS:
				sequence_SquareBracketedClauseCS(context, (SquareBracketedClauseCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.STRING_LITERAL_EXP_CS:
				sequence_StringLiteralExpCS(context, (StringLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.TUPLE_LITERAL_EXP_CS:
				sequence_TupleLiteralExpCS(context, (TupleLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.TUPLE_LITERAL_PART_CS:
				sequence_TupleLiteralPartCS(context, (TupleLiteralPartCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.TYPE_LITERAL_EXP_CS:
				sequence_TypeLiteralExpCS(context, (TypeLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.TYPE_NAME_EXP_CS:
				if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_TypeExpCS_TypeNameExpCS(context, (TypeNameExpCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeNameExpCSRule()) {
					sequence_TypeNameExpCS(context, (TypeNameExpCS) semanticObject); 
					return; 
				}
				else break;
			case EssentialOCLCSPackage.UNLIMITED_NATURAL_LITERAL_EXP_CS:
				sequence_UnlimitedNaturalLiteralExpCS(context, (UnlimitedNaturalLiteralExpCS) semanticObject); 
				return; 
			case EssentialOCLCSPackage.VARIABLE_CS:
				if(context == grammarAccess.getObjectVariableCSRule()) {
					sequence_ObjectVariableCS(context, (VariableCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeSelectorCSRule()) {
					sequence_TypeSelectorCS(context, (VariableCS) semanticObject); 
					return; 
				}
				else break;
			}
		else if(semanticObject.eClass().getEPackage() == ImperativeOCLCSPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case ImperativeOCLCSPackage.ASSERT_EXP_CS:
				sequence_AssertExpCS(context, (AssertExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.ASSIGN_EXP_CS:
				sequence_AssignExpCS(context, (AssignExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.BREAK_EXP_CS:
				sequence_BreakExpCS(context, (BreakExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.CATCH_EXP_CS:
				sequence_CatchExpCS(context, (CatchExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.COMPUTE_EXP_CS:
				sequence_ComputeExpCS(context, (ComputeExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.CONTINUE_EXP_CS:
				sequence_ContinueExpCS(context, (ContinueExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.DICT_LITERAL_EXP_CS:
				sequence_DictLiteralExpCS(context, (DictLiteralExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.DICT_LITERAL_PART_CS:
				sequence_DictLiteralPartCS(context, (DictLiteralPartCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.DICT_TYPE_CS:
				if(context == grammarAccess.getDictTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_DictTypeCS(context, (DictTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_DictTypeCS_TypeExpCS(context, (DictTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_DictTypeCS_TypeLiteralWithMultiplicityCS(context, (DictTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_DictTypeCS_TypedMultiplicityRef2CS(context, (DictTypeCS) semanticObject); 
					return; 
				}
				else break;
			case ImperativeOCLCSPackage.EXPRESSION_BLOCK_CS:
				sequence_ExpressionBlockCS(context, (ExpressionBlockCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.EXTENT_REF_CS:
				sequence_ExtentRefCS(context, (ExtentRefCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.FOR_EXP_CS:
				sequence_ForExpCS(context, (ForExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.IMPERATIVE_ITERATE_EXP_CS:
				sequence_ImperativeIterateExpCS(context, (ImperativeIterateExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.INSTANTIATION_EXP_CS:
				sequence_InstantiationExpCS(context, (InstantiationExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.LIST_LITERAL_EXP_CS:
				sequence_ListLiteralExpCS(context, (ListLiteralExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.LIST_TYPE_CS:
				if(context == grammarAccess.getListTypeCSRule() ||
				   context == grammarAccess.getTypeLiteralCSRule() ||
				   context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule()) {
					sequence_ListTypeCS(context, (ListTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeExpCSRule()) {
					sequence_ListTypeCS_TypeExpCS(context, (ListTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeLiteralWithMultiplicityCSRule()) {
					sequence_ListTypeCS_TypeLiteralWithMultiplicityCS(context, (ListTypeCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_ListTypeCS_TypedMultiplicityRef2CS(context, (ListTypeCS) semanticObject); 
					return; 
				}
				else break;
			case ImperativeOCLCSPackage.LOG_EXP_CS:
				sequence_LogExpCS(context, (LogExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.RAISE_EXP_CS:
				sequence_RaiseExpCS(context, (RaiseExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.RETURN_EXP_CS:
				sequence_ReturnExpCS(context, (ReturnExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.SWITCH_ALT_CS:
				sequence_SwitchAltCS(context, (SwitchAltCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.SWITCH_EXP_CS:
				sequence_SwitchExpCS(context, (SwitchExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.TRY_EXP_CS:
				sequence_TryExpCS(context, (TryExpCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.VAR_DECLARATION_CS:
				if(context == grammarAccess.getVarDeclarationCSRule()) {
					sequence_VarDeclarationCS(context, (VarDeclarationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getVarDeclarationNoInitCSRule()) {
					sequence_VarDeclarationNoInitCS(context, (VarDeclarationCS) semanticObject); 
					return; 
				}
				else break;
			case ImperativeOCLCSPackage.VARS_INITIALIZATION_CS:
				sequence_VarsInitializationCS(context, (VarsInitializationCS) semanticObject); 
				return; 
			case ImperativeOCLCSPackage.WHILE_EXP_CS:
				sequence_WhileExpCS(context, (WhileExpCS) semanticObject); 
				return; 
			}
		else if(semanticObject.eClass().getEPackage() == QVTOperationalCSPackage.eINSTANCE) switch(semanticObject.eClass().getClassifierID()) {
			case QVTOperationalCSPackage.CLASSIFIER_PROPERTY_CS:
				sequence_ClassifierPropertyCS(context, (ClassifierPropertyCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.CONFIGURATION_PROPERTY_CS:
				sequence_ConfigurationPropertyCS(context, (ConfigurationPropertyCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.CONSTRUCTOR_OPERATION_CS:
				if(context == grammarAccess.getConstructorDefinitionCSRule()) {
					sequence_ConstructorDefinitionCS_ConstructorHeaderCS(context, (ConstructorOperationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getConstructorCSRule() ||
				   context == grammarAccess.getConstructorDeclarationCSRule() ||
				   context == grammarAccess.getConstructorHeaderCSRule() ||
				   context == grammarAccess.getModuleOperationCSRule()) {
					sequence_ConstructorHeaderCS(context, (ConstructorOperationCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.CONTEXTUAL_PROPERTY_CS:
				sequence_ContextualPropertyCS(context, (ContextualPropertyCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.ENTRY_OPERATION_CS:
				sequence_EntryOperationCS(context, (EntryOperationCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.HELPER_OPERATION_CS:
				if(context == grammarAccess.getHelperCompoundDefinitionCSRule()) {
					sequence_HelperCompoundDefinitionCS_HelperHeaderCS(context, (HelperOperationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getHelperCSRule() ||
				   context == grammarAccess.getHelperDeclarationCSRule() ||
				   context == grammarAccess.getHelperHeaderCSRule() ||
				   context == grammarAccess.getModuleOperationCSRule()) {
					sequence_HelperHeaderCS(context, (HelperOperationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getHelperDefinitionCSRule() ||
				   context == grammarAccess.getHelperSimpleDefinitionCSRule()) {
					sequence_HelperHeaderCS_HelperSimpleDefinitionCS(context, (HelperOperationCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.INIT_PART_CS:
				sequence_InitPartCS(context, (InitPartCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MAPPING_BODY_CS:
				sequence_MappingBodyCS(context, (MappingBodyCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MAPPING_CALL_EXP_CS:
				sequence_MappingCallExpCS(context, (MappingCallExpCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MAPPING_OPERATION_CS:
				if(context == grammarAccess.getMappingDefinitionCSRule()) {
					sequence_MappingDefinitionCS_MappingOperationHeaderCS(context, (MappingOperationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getMappingDeclarationCSRule() ||
				   context == grammarAccess.getMappingOperationCSRule() ||
				   context == grammarAccess.getMappingOperationHeaderCSRule() ||
				   context == grammarAccess.getModuleOperationCSRule()) {
					sequence_MappingOperationHeaderCS(context, (MappingOperationCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.METAMODEL_CS:
				sequence_MetamodelCS(context, (MetamodelCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MODEL_TYPE_CS:
				sequence_ModelTypeCS(context, (ModelTypeCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MODEL_TYPE_REF_CS:
				sequence_ModelTypeRefCS(context, (ModelTypeRefCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MODULE_REF_CS:
				sequence_ModuleRefCS(context, (ModuleRefCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.MODULE_USAGE_CS:
				sequence_ModuleUsageCS(context, (ModuleUsageCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.OBJECT_EXP_CS:
				sequence_ObjectExpCS(context, (ObjectExpCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.OPERATION_BODY_CS:
				if(context == grammarAccess.getCompoundOperationBodyCSRule()) {
					sequence_CompoundOperationBodyCS(context, (OperationBodyCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getSimpleOperationBodyCSRule()) {
					sequence_SimpleOperationBodyCS(context, (OperationBodyCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.OPERATION_REF_CS:
				sequence_OperationRefCS(context, (OperationRefCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.PACKAGE_REF_CS:
				sequence_PackageRefCS(context, (PackageRefCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.PARAMETER_DECLARATION_CS:
				sequence_ParameterDeclarationCS(context, (ParameterDeclarationCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.PATH_ELEMENT2_CS:
				sequence_PathElement2CS(context, (PathElement2CS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.PATH_NAME2_CS:
				sequence_PathName2CS(context, (PathName2CS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.PRIMITIVE_TYPE_CS:
				sequence_DataTypeCS(context, (PrimitiveTypeCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.QV_TO_CLASS_CS:
				sequence_QVToClassCS(context, (QVToClassCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.QV_TO_IMPORT_CS:
				sequence_ImportCS(context, (QVToImportCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.QV_TO_LIBRARY_CS:
				if(context == grammarAccess.getLibraryDefCSRule()) {
					sequence_LibraryDefCS_LibraryHeaderCS(context, (QVToLibraryCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getLibraryCSRule() ||
				   context == grammarAccess.getLibraryDeclCSRule() ||
				   context == grammarAccess.getLibraryHeaderCSRule() ||
				   context == grammarAccess.getUnitTypeCSRule()) {
					sequence_LibraryHeaderCS(context, (QVToLibraryCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.QV_TO_OPERATION_CS:
				sequence_ClassifierOperationCS(context, (QVToOperationCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.RESOLVE_BY_MAPPING_EXP_CS:
				sequence_ResolveByMappingExpCS(context, (ResolveByMappingExpCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.RESOLVE_BY_TYPE_EXP_CS:
				sequence_ResolveByTypeExpCS(context, (ResolveByTypeExpCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.STEREOTYPE_QUALIFIER_CS:
				sequence_StereotypeQualifierCS(context, (StereotypeQualifierCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.TAG_CS:
				sequence_TagCS(context, (TagCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.TOP_LEVEL_CS:
				sequence_TopLevelCS(context, (TopLevelCS) semanticObject); 
				return; 
			case QVTOperationalCSPackage.TRANSFORMATION_CS:
				if(context == grammarAccess.getTransformationDefCSRule()) {
					sequence_TransformationDefCS_TransformationHeaderCS(context, (TransformationCS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTransformationCSRule() ||
				   context == grammarAccess.getTransformationDeclCSRule() ||
				   context == grammarAccess.getTransformationHeaderCSRule() ||
				   context == grammarAccess.getUnitTypeCSRule()) {
					sequence_TransformationHeaderCS(context, (TransformationCS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.TYPED_TYPE_REF2_CS:
				if(context == grammarAccess.getTypedMultiplicityRef2CSRule()) {
					sequence_TypedMultiplicityRef2CS_TypedTypeRef2CS(context, (TypedTypeRef2CS) semanticObject); 
					return; 
				}
				else if(context == grammarAccess.getTypeRefCSRule() ||
				   context == grammarAccess.getTypedRef2CSRule() ||
				   context == grammarAccess.getTypedTypeRef2CSRule()) {
					sequence_TypedTypeRef2CS(context, (TypedTypeRef2CS) semanticObject); 
					return; 
				}
				else break;
			case QVTOperationalCSPackage.UNIT_REF_CS:
				sequence_UnitRefCS(context, (UnitRefCS) semanticObject); 
				return; 
			}
		if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Constraint:
	 *     (
	 *         ownedStereotype=StereotypeQualifierCS? 
	 *         qualifiers+=FeatureQualifier* 
	 *         name=UnrestrictedName 
	 *         (ownedParameters+=ParameterCS ownedParameters+=ParameterCS*)? 
	 *         ownedType=TypedMultiplicityRef2CS?
	 *     )
	 */
	protected void sequence_ClassifierOperationCS(EObject context, QVToOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         ownedStereotype=StereotypeQualifierCS? 
	 *         qualifiers+=FeatureQualifier* 
	 *         name=UnrestrictedName 
	 *         ownedType=TypedMultiplicityRef2CS 
	 *         default=SINGLE_QUOTED_STRING? 
	 *         opposite=Identifier?
	 *     )
	 */
	protected void sequence_ClassifierPropertyCS(EObject context, ClassifierPropertyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=CollectionTypeIdentifier ownedType=TypeExpCS? ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_CollectionTypeCS_TypedMultiplicityRef2CS(EObject context, CollectionTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedContentExps+=ExpressionStatementCS*)
	 */
	protected void sequence_CompoundOperationBodyCS(EObject context, OperationBodyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedScopedName=PathName2CS ownedType=TypeLiteralCS default=StringLiteral)
	 */
	protected void sequence_ConfigurationPropertyCS(EObject context, ConfigurationPropertyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterCS ownedParameters+=ParameterCS*)? 
	 *         ownedBody=CompoundOperationBodyCS
	 *     )
	 */
	protected void sequence_ConstructorDefinitionCS_ConstructorHeaderCS(EObject context, ConstructorOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (qualifiers+=OperationQualifier* ownedScopedName=PathName2CS (ownedParameters+=ParameterCS ownedParameters+=ParameterCS*)?)
	 */
	protected void sequence_ConstructorHeaderCS(EObject context, ConstructorOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedScopedName=PathName2CS ownedType=TypedMultiplicityRef2CS ownedInitExp=ExpCS?)
	 */
	protected void sequence_ContextualPropertyCS(EObject context, ContextualPropertyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=UnrestrictedName
	 */
	protected void sequence_DataTypeCS(EObject context, DataTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=UnrestrictedName
	 */
	protected void sequence_DataTypeCS(EObject context, PrimitiveTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedKeyTypeRef=TypeExpCS ownedValueTypeRef=TypeExpCS ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_DictTypeCS_TypedMultiplicityRef2CS(EObject context, DictTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ownedBody=CompoundOperationBodyCS
	 */
	protected void sequence_EntryOperationCS(EObject context, EntryOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=Identifier ownedLiterals+=EnumerationLiteralCS ownedLiterals+=EnumerationLiteralCS*)
	 */
	protected void sequence_EnumerationCS(EObject context, EnumerationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=UnrestrictedName
	 */
	protected void sequence_EnumerationLiteralCS(EObject context, EnumerationLiteralCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=UnrestrictedName (ownedSuperTypes+=TypedRefCS ownedSuperTypes+=TypedRefCS*)?)
	 */
	protected void sequence_ExceptionCS(EObject context, StructuredClassCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         isQuery?='query'? 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)? 
	 *         (ownedResults+=ParameterDeclarationCS ownedResults+=ParameterDeclarationCS)? 
	 *         ownedBody=CompoundOperationBodyCS
	 *     )
	 */
	protected void sequence_HelperCompoundDefinitionCS_HelperHeaderCS(EObject context, HelperOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         isQuery?='query'? 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)? 
	 *         (ownedResults+=ParameterDeclarationCS ownedResults+=ParameterDeclarationCS)?
	 *     )
	 */
	protected void sequence_HelperHeaderCS(EObject context, HelperOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         isQuery?='query'? 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)? 
	 *         (ownedResults+=ParameterDeclarationCS ownedResults+=ParameterDeclarationCS)? 
	 *         ownedBody=SimpleOperationBodyCS
	 *     )
	 */
	protected void sequence_HelperHeaderCS_HelperSimpleDefinitionCS(EObject context, HelperOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedUnitRef=UnitRefCS | (ownedUnitRef=UnitRefCS ((importedUnitElement+=Identifier importedUnitElement+=Identifier*) | isAll?='*')))
	 */
	protected void sequence_ImportCS(EObject context, QVToImportCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (initOp=InitOpCS ownedExp=ExpCS)
	 */
	protected void sequence_InitPartCS(EObject context, InitPartCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         ownedQualifiers+=LibraryQualifier* 
	 *         name=UnrestrictedName 
	 *         ownedParameters+=ModelTypeRefCS 
	 *         ownedParameters+=ModelTypeRefCS* 
	 *         ownedModuleUsages+=ModuleUsageCS* 
	 *         (ownedProperties+=ModulePropertyCS | ownedOperations+=ModuleOperationCS | ownedAnnotations+=TagCS)*
	 *     )
	 */
	protected void sequence_LibraryDefCS_LibraryHeaderCS(EObject context, QVToLibraryCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         ownedQualifiers+=LibraryQualifier* 
	 *         name=UnrestrictedName 
	 *         ownedParameters+=ModelTypeRefCS 
	 *         ownedParameters+=ModelTypeRefCS* 
	 *         ownedModuleUsages+=ModuleUsageCS*
	 *     )
	 */
	protected void sequence_LibraryHeaderCS(EObject context, QVToLibraryCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedTypeRef=TypeExpCS ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_ListTypeCS_TypedMultiplicityRef2CS(EObject context, ListTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name='Map' (ownedKeyType=TypeExpCS ownedValueType=TypeExpCS)? ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_MapTypeCS_TypedMultiplicityRef2CS(EObject context, MapTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedInitExps+=ExpCS? ((hasPopulationKeyword?='population'? ownedContentExps+=ExpCS*) | ownedContentExps+=ExpCS) ownedEndExps+=ExpCS?)
	 */
	protected void sequence_MappingBodyCS(EObject context, MappingBodyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (isStrict?='xmap'? ownedPathName=PathNameCS ownedRoundBracketedClause=RoundBracketedClauseCS)
	 */
	protected void sequence_MappingCallExpCS(EObject context, MappingCallExpCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         direction=DirectionKindCS? 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)? 
	 *         (ownedResults+=ParameterDeclarationCS ownedResults+=ParameterDeclarationCS)? 
	 *         (ownedInheritRefs+=OperationRefCS ownedInheritRefs+=OperationRefCS*)? 
	 *         (ownedMergeRefs+=OperationRefCS ownedMergeRefs+=OperationRefCS*)? 
	 *         (ownedDisjunctRefs+=OperationRefCS ownedDisjunctRefs+=OperationRefCS*)? 
	 *         ownedRefinedRule=PathName2CS? 
	 *         ownedWhenExps+=ExpCS* 
	 *         ownedWhereExps+=ExpressionBlockCS* 
	 *         ownedBody=MappingBodyCS
	 *     )
	 */
	protected void sequence_MappingDefinitionCS_MappingOperationHeaderCS(EObject context, MappingOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         qualifiers+=OperationQualifier* 
	 *         direction=DirectionKindCS? 
	 *         ownedScopedName=PathName2CS 
	 *         (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)? 
	 *         (ownedResults+=ParameterDeclarationCS ownedResults+=ParameterDeclarationCS)? 
	 *         (ownedInheritRefs+=OperationRefCS ownedInheritRefs+=OperationRefCS*)? 
	 *         (ownedMergeRefs+=OperationRefCS ownedMergeRefs+=OperationRefCS*)? 
	 *         (ownedDisjunctRefs+=OperationRefCS ownedDisjunctRefs+=OperationRefCS*)? 
	 *         ownedRefinedRule=PathName2CS? 
	 *         ownedWhenExps+=ExpCS* 
	 *         ownedWhereExps+=ExpressionBlockCS*
	 *     )
	 */
	protected void sequence_MappingOperationHeaderCS(EObject context, MappingOperationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (metamodelKind=MetamodelKindCS name=UnrestrictedName (ownedClasses+=ClassCS | ownedClasses+=EnumerationCS | ownedAnnotations+=TagCS)*)
	 */
	protected void sequence_MetamodelCS(EObject context, MetamodelCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         name=UnrestrictedName 
	 *         complianceKind=StringLiteral? 
	 *         ownedPackageRefs+=PackageRefCS 
	 *         ownedPackageRefs+=PackageRefCS* 
	 *         (ownedConditions+=ExpCS ownedConditions+=ExpCS*)?
	 *     )
	 */
	protected void sequence_ModelTypeCS(EObject context, ModelTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ownedType=TypedTypeRef2CS
	 */
	protected void sequence_ModelTypeRefCS(EObject context, ModelTypeRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedScopedName=PathName2CS (ownedParameters+=ParameterDeclarationCS ownedParameters+=ParameterDeclarationCS*)?)
	 */
	protected void sequence_ModuleRefCS(EObject context, ModuleRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (importKind=ImportKindCS moduleKind=ModuleKindCS? ownedModuleRefs+=ModuleRefCS ownedModuleRefs+=ModuleRefCS*)
	 */
	protected void sequence_ModuleUsageCS(EObject context, ModuleUsageCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (lowerBound=LOWER? upperBound=UPPER)
	 */
	protected void sequence_MultiplicityCS(EObject context, MultiplicityBoundsCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedIterator=VarDeclarationNoInitCS? ownedVariable=ObjectVariableCS ownedExtentRef=ExtentRefCS? ownedExps+=ExpCS*)
	 */
	protected void sequence_ObjectExpCS(EObject context, ObjectExpCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((name=UnrestrictedName ownedType=TypedTypeRef2CS?) | ownedType=TypedTypeRef2CS)
	 */
	protected void sequence_ObjectVariableCS(EObject context, VariableCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ownedPathName=PathName2CS
	 */
	protected void sequence_OperationRefCS(EObject context, OperationRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (uri=StringLiteral | (ownedScopedName=PathName2CS uri=StringLiteral))
	 */
	protected void sequence_PackageRefCS(EObject context, PackageRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=UnrestrictedName ownedType=TypedMultiplicityRef2CS?)
	 */
	protected void sequence_ParameterCS(EObject context, ParameterCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (direction=DirectionKindCS? name=UnrestrictedName ownedType=TypedMultiplicityRef2CS? ownedInitPart=InitPartCS?)
	 */
	protected void sequence_ParameterDeclarationCS(EObject context, ParameterDeclarationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     name=UnrestrictedName
	 */
	protected void sequence_PathElement2CS(EObject context, PathElement2CS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedPathElements2+=PathElement2CS ownedPathElements2+=PathElement2CS*)
	 */
	protected void sequence_PathName2CS(EObject context, PathName2CS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=PrimitiveTypeIdentifier ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_PrimitiveTypeCS_TypedMultiplicityRef2CS(EObject context, PrimitiveTypeRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         isIntermediate?='intermediate'? 
	 *         name=UnrestrictedName 
	 *         (ownedSuperTypes+=TypedRefCS ownedSuperTypes+=TypedRefCS*)? 
	 *         (ownedProperties+=ClassifierPropertyCS | ownedOperations+=ClassifierOperationCS | ownedAnnotations+=TagCS)*
	 *     )
	 */
	protected void sequence_QVToClassCS(EObject context, QVToClassCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         isDeferred?='late'? 
	 *         (name='resolveIn' | name='resolveoneIn' | name='resolveinvIn' | name='resolveinvoneIn') 
	 *         ownedMappingRef=OperationRefCS 
	 *         (ownedTarget=VarDeclarationNoInitCS ownedCondition=ExpCS)?
	 *     )
	 */
	protected void sequence_ResolveByMappingExpCS(EObject context, ResolveByMappingExpCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         isDeferred?='late'? 
	 *         (name='resolve' | name='resolveone' | name='resolveinv' | name='resolveinvone') 
	 *         ownedTarget=TypeSelectorCS 
	 *         ownedCondition=ExpCS?
	 *     )
	 */
	protected void sequence_ResolveByTypeExpCS(EObject context, ResolveByTypeExpCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ownedContentExps+=ExpCS
	 */
	protected void sequence_SimpleOperationBodyCS(EObject context, OperationBodyCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (stereotypes+=Identifier stereotypes+=Identifier*)
	 */
	protected void sequence_StereotypeQualifierCS(EObject context, StereotypeQualifierCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     ((name=UnrestrictedName | name=SINGLE_QUOTED_STRING)? ownedElementPath=PathName2CS ownedExpression=ExpCS?)
	 */
	protected void sequence_TagCS(EObject context, TagCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedImports+=ImportCS* (ownedPackages+=UnitPackageCS | ownedTypes+=UnitTypeCS | ownedAnnotations+=TagCS)*)
	 */
	protected void sequence_TopLevelCS(EObject context, TopLevelCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         ownedQualifiers+=TransformationQualifier* 
	 *         name=UnrestrictedName 
	 *         ownedParameters+=ParameterDeclarationCS 
	 *         ownedParameters+=ParameterDeclarationCS* 
	 *         ownedModuleUsages+=ModuleUsageCS* 
	 *         ownedRefinedModule=ModuleRefCS? 
	 *         (ownedProperties+=ModulePropertyCS | ownedOperations+=ModuleOperationCS | ownedAnnotations+=TagCS)*
	 *     )
	 */
	protected void sequence_TransformationDefCS_TransformationHeaderCS(EObject context, TransformationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (
	 *         ownedQualifiers+=TransformationQualifier* 
	 *         name=UnrestrictedName 
	 *         ownedParameters+=ParameterDeclarationCS 
	 *         ownedParameters+=ParameterDeclarationCS* 
	 *         ownedModuleUsages+=ModuleUsageCS* 
	 *         ownedRefinedModule=ModuleRefCS?
	 *     )
	 */
	protected void sequence_TransformationHeaderCS(EObject context, TransformationCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name='Tuple' (ownedParts+=TuplePartCS ownedParts+=TuplePartCS*)? ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_TupleTypeCS_TypedMultiplicityRef2CS(EObject context, TupleTypeCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (name=UnrestrictedName? ownedType=TypedRef2CS)
	 */
	protected void sequence_TypeSelectorCS(EObject context, VariableCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedPathName=PathName2CS ownedBinding=TemplateBindingCS? extentLocation=UnrestrictedName? ownedMultiplicity=MultiplicityCS?)
	 */
	protected void sequence_TypedMultiplicityRef2CS_TypedTypeRef2CS(EObject context, TypedTypeRef2CS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (ownedPathName=PathName2CS ownedBinding=TemplateBindingCS? extentLocation=UnrestrictedName?)
	 */
	protected void sequence_TypedTypeRef2CS(EObject context, TypedTypeRef2CS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Constraint:
	 *     (segment+=Identifier segment+=Identifier*)
	 */
	protected void sequence_UnitRefCS(EObject context, UnitRefCS semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
}