org.eclipse.osbp.xtext.datamartdsl/src-gen/org/eclipse/osbp/xtext/datamartdsl/serializer/DatamartDSLSemanticSequencer.java

/**
 *                                                                            
 *  Copyright (c) 2011, 2017 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
 *                                                                            
 *  All rights reserved. This program and the accompanying materials           
 *  are made available under the terms of the Eclipse Public License v1.0       
 *  which accompanies this distribution, and is available at                  
 *  http://www.eclipse.org/legal/epl-v10.html                                 
 *                                                                            
 *  Contributors:                                                      
 * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
 * 
 * generated by Xtext 2.11.0
 *
 */

package org.eclipse.osbp.xtext.datamartdsl.serializer;

import com.google.inject.Inject;
import java.util.Set;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.osbp.xtext.datamartdsl.Addition;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerData;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateFuture;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDatePast;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerDateRange;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRandom;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedDoubleRange;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRandom;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerSignedIntegerRange;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextParagraphs;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextRandom;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextSentences;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerTextWords;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRandom;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedDoubleRange;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRandom;
import org.eclipse.osbp.xtext.datamartdsl.AttributeFillerUnsignedIntegerRange;
import org.eclipse.osbp.xtext.datamartdsl.ConditionalExpression;
import org.eclipse.osbp.xtext.datamartdsl.Conjunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAggregation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAggregationFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttribute;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAttributeBase;
import org.eclipse.osbp.xtext.datamartdsl.DatamartAxis;
import org.eclipse.osbp.xtext.datamartdsl.DatamartColumn;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCondition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCube;
import org.eclipse.osbp.xtext.datamartdsl.DatamartCubeAxis;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDSLPackage;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefineDerivedMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDefinition;
import org.eclipse.osbp.xtext.datamartdsl.DatamartDerivedMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartEntity;
import org.eclipse.osbp.xtext.datamartdsl.DatamartFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartFunctionIntParameter;
import org.eclipse.osbp.xtext.datamartdsl.DatamartHierarchy;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMeasure;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMember;
import org.eclipse.osbp.xtext.datamartdsl.DatamartMemberTuple;
import org.eclipse.osbp.xtext.datamartdsl.DatamartModel;
import org.eclipse.osbp.xtext.datamartdsl.DatamartOrder;
import org.eclipse.osbp.xtext.datamartdsl.DatamartOwner;
import org.eclipse.osbp.xtext.datamartdsl.DatamartPackage;
import org.eclipse.osbp.xtext.datamartdsl.DatamartParameterFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartReference;
import org.eclipse.osbp.xtext.datamartdsl.DatamartRole;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregation;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetAggregationFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetParameterFunction;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSetTuple;
import org.eclipse.osbp.xtext.datamartdsl.DatamartSlicer;
import org.eclipse.osbp.xtext.datamartdsl.DatamartTask;
import org.eclipse.osbp.xtext.datamartdsl.DatamartTaskFilter;
import org.eclipse.osbp.xtext.datamartdsl.Disjunction;
import org.eclipse.osbp.xtext.datamartdsl.Division;
import org.eclipse.osbp.xtext.datamartdsl.Expression;
import org.eclipse.osbp.xtext.datamartdsl.Multiplication;
import org.eclipse.osbp.xtext.datamartdsl.Subtraction;
import org.eclipse.osbp.xtext.datamartdsl.services.DatamartDSLGrammarAccess;
import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSemanticSequencer;
import org.eclipse.xtext.Action;
import org.eclipse.xtext.Parameter;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.common.types.JvmFormalParameter;
import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference;
import org.eclipse.xtext.common.types.JvmInnerTypeReference;
import org.eclipse.xtext.common.types.JvmLowerBound;
import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
import org.eclipse.xtext.common.types.JvmTypeParameter;
import org.eclipse.xtext.common.types.JvmUpperBound;
import org.eclipse.xtext.common.types.JvmWildcardTypeReference;
import org.eclipse.xtext.common.types.TypesPackage;
import org.eclipse.xtext.serializer.ISerializationContext;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;
import org.eclipse.xtext.xbase.XAssignment;
import org.eclipse.xtext.xbase.XBasicForLoopExpression;
import org.eclipse.xtext.xbase.XBinaryOperation;
import org.eclipse.xtext.xbase.XBlockExpression;
import org.eclipse.xtext.xbase.XBooleanLiteral;
import org.eclipse.xtext.xbase.XCasePart;
import org.eclipse.xtext.xbase.XCastedExpression;
import org.eclipse.xtext.xbase.XCatchClause;
import org.eclipse.xtext.xbase.XClosure;
import org.eclipse.xtext.xbase.XConstructorCall;
import org.eclipse.xtext.xbase.XDoWhileExpression;
import org.eclipse.xtext.xbase.XFeatureCall;
import org.eclipse.xtext.xbase.XForLoopExpression;
import org.eclipse.xtext.xbase.XIfExpression;
import org.eclipse.xtext.xbase.XInstanceOfExpression;
import org.eclipse.xtext.xbase.XListLiteral;
import org.eclipse.xtext.xbase.XMemberFeatureCall;
import org.eclipse.xtext.xbase.XNullLiteral;
import org.eclipse.xtext.xbase.XNumberLiteral;
import org.eclipse.xtext.xbase.XPostfixOperation;
import org.eclipse.xtext.xbase.XReturnExpression;
import org.eclipse.xtext.xbase.XSetLiteral;
import org.eclipse.xtext.xbase.XStringLiteral;
import org.eclipse.xtext.xbase.XSwitchExpression;
import org.eclipse.xtext.xbase.XSynchronizedExpression;
import org.eclipse.xtext.xbase.XThrowExpression;
import org.eclipse.xtext.xbase.XTryCatchFinallyExpression;
import org.eclipse.xtext.xbase.XTypeLiteral;
import org.eclipse.xtext.xbase.XUnaryOperation;
import org.eclipse.xtext.xbase.XVariableDeclaration;
import org.eclipse.xtext.xbase.XWhileExpression;
import org.eclipse.xtext.xbase.XbasePackage;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationElementValuePair;
import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationsPackage;
import org.eclipse.xtext.xtype.XFunctionTypeRef;
import org.eclipse.xtext.xtype.XImportSection;
import org.eclipse.xtext.xtype.XtypePackage;

@SuppressWarnings("all")
public class DatamartDSLSemanticSequencer extends OXtypeSemanticSequencer {

	@Inject
	private DatamartDSLGrammarAccess grammarAccess;
	
	@Override
	public void sequence(ISerializationContext context, EObject semanticObject) {
		EPackage epackage = semanticObject.eClass().getEPackage();
		ParserRule rule = context.getParserRule();
		Action action = context.getAssignedAction();
		Set<Parameter> parameters = context.getEnabledBooleanParameters();
		if (epackage == DatamartDSLPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case DatamartDSLPackage.ADDITION:
				sequence_DatamartAddition(context, (Addition) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_DATA:
				sequence_AttributeFillerData(context, (AttributeFillerData) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_DATE_FUTURE:
				sequence_AttributeFillerDateFuture(context, (AttributeFillerDateFuture) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_DATE_PAST:
				sequence_AttributeFillerDatePast(context, (AttributeFillerDatePast) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_DATE_RANGE:
				sequence_AttributeFillerDateRange(context, (AttributeFillerDateRange) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_SIGNED_DOUBLE_RANDOM:
				sequence_AttributeFillerSignedDoubleRandom(context, (AttributeFillerSignedDoubleRandom) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_SIGNED_DOUBLE_RANGE:
				sequence_AttributeFillerSignedDoubleRange(context, (AttributeFillerSignedDoubleRange) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_SIGNED_INTEGER_RANDOM:
				sequence_AttributeFillerSignedIntegerRandom(context, (AttributeFillerSignedIntegerRandom) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_SIGNED_INTEGER_RANGE:
				sequence_AttributeFillerSignedIntegerRange(context, (AttributeFillerSignedIntegerRange) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_TEXT_PARAGRAPHS:
				sequence_AttributeFillerTextParagraphs(context, (AttributeFillerTextParagraphs) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_TEXT_RANDOM:
				sequence_AttributeFillerTextRandom(context, (AttributeFillerTextRandom) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_TEXT_SENTENCES:
				sequence_AttributeFillerTextSentences(context, (AttributeFillerTextSentences) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_TEXT_WORDS:
				sequence_AttributeFillerTextWords(context, (AttributeFillerTextWords) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_UNSIGNED_DOUBLE_RANDOM:
				sequence_AttributeFillerUnsignedDoubleRandom(context, (AttributeFillerUnsignedDoubleRandom) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_UNSIGNED_DOUBLE_RANGE:
				sequence_AttributeFillerUnsignedDoubleRange(context, (AttributeFillerUnsignedDoubleRange) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_UNSIGNED_INTEGER_RANDOM:
				sequence_AttributeFillerUnsignedIntegerRandom(context, (AttributeFillerUnsignedIntegerRandom) semanticObject); 
				return; 
			case DatamartDSLPackage.ATTRIBUTE_FILLER_UNSIGNED_INTEGER_RANGE:
				sequence_AttributeFillerUnsignedIntegerRange(context, (AttributeFillerUnsignedIntegerRange) semanticObject); 
				return; 
			case DatamartDSLPackage.CONDITIONAL_EXPRESSION:
				sequence_DatamartConditionalExpression(context, (ConditionalExpression) semanticObject); 
				return; 
			case DatamartDSLPackage.CONJUNCTION:
				sequence_DatamartConjunction(context, (Conjunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_AGGREGATION:
				sequence_DatamartAggregation(context, (DatamartAggregation) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_AGGREGATION_FUNCTION:
				sequence_DatamartAggregationFunction(context, (DatamartAggregationFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_ATTRIBUTE:
				sequence_DatamartAttribute(context, (DatamartAttribute) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_ATTRIBUTE_BASE:
				sequence_DatamartAttributeBase(context, (DatamartAttributeBase) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_AXIS:
				sequence_DatamartAxis(context, (DatamartAxis) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_COLUMN:
				sequence_DatamartColumn(context, (DatamartColumn) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_CONDITION:
				sequence_DatamartCondition(context, (DatamartCondition) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_CUBE:
				sequence_DatamartCube(context, (DatamartCube) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_CUBE_AXIS:
				sequence_DatamartCubeAxis(context, (DatamartCubeAxis) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_DEFINE_DERIVED_MEASURE:
				sequence_DatamartDefineDerivedMeasure(context, (DatamartDefineDerivedMeasure) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_DEFINITION:
				sequence_DatamartDefinition(context, (DatamartDefinition) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_DERIVED_MEASURE:
				sequence_DatamartDerivedMeasure(context, (DatamartDerivedMeasure) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_ENTITY:
				sequence_DatamartEntity(context, (DatamartEntity) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_FUNCTION:
				sequence_DatamartFunction(context, (DatamartFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_FUNCTION_INT_PARAMETER:
				sequence_DatamartFunctionIntParameter(context, (DatamartFunctionIntParameter) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_HIERARCHY:
				sequence_DatamartHierarchy(context, (DatamartHierarchy) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_MEASURE:
				sequence_DatamartMeasure(context, (DatamartMeasure) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_MEMBER:
				sequence_DatamartMember(context, (DatamartMember) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_MEMBER_TUPLE:
				sequence_DatamartMemberTuple(context, (DatamartMemberTuple) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_MODEL:
				sequence_DatamartModel(context, (DatamartModel) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_ORDER:
				sequence_DatamartOrder(context, (DatamartOrder) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_OWNER:
				sequence_DatamartOwner(context, (DatamartOwner) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_PACKAGE:
				sequence_DatamartPackage(context, (DatamartPackage) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_PARAMETER_FUNCTION:
				sequence_DatamartParameterFunction(context, (DatamartParameterFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_REFERENCE:
				sequence_DatamartReference(context, (DatamartReference) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_ROLE:
				sequence_DatamartRole(context, (DatamartRole) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SET_AGGREGATION:
				sequence_DatamartSetAggregation(context, (DatamartSetAggregation) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SET_AGGREGATION_FUNCTION:
				sequence_DatamartSetAggregationFunction(context, (DatamartSetAggregationFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SET_FUNCTION:
				sequence_DatamartSetFunction(context, (DatamartSetFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SET_PARAMETER_FUNCTION:
				sequence_DatamartSetParameterFunction(context, (DatamartSetParameterFunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SET_TUPLE:
				sequence_DatamartSetTuple(context, (DatamartSetTuple) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_SLICER:
				sequence_DatamartSlicer(context, (DatamartSlicer) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_TASK:
				sequence_DatamartTask(context, (DatamartTask) semanticObject); 
				return; 
			case DatamartDSLPackage.DATAMART_TASK_FILTER:
				sequence_DatamartTaskFilter(context, (DatamartTaskFilter) semanticObject); 
				return; 
			case DatamartDSLPackage.DISJUNCTION:
				sequence_DatamartDisjunction(context, (Disjunction) semanticObject); 
				return; 
			case DatamartDSLPackage.DIVISION:
				sequence_DatamartMultiplication(context, (Division) semanticObject); 
				return; 
			case DatamartDSLPackage.EXPRESSION:
				if (action == grammarAccess.getDatamartAggregationAccess().getDatamartAggregationLeftAction_3_0()) {
					sequence_DatamartAggregation_DatamartAggregation_3_0(context, (Expression) semanticObject); 
					return; 
				}
				else if (action == grammarAccess.getDatamartMemberTupleAccess().getDatamartMemberTupleLeftAction_2_0()) {
					sequence_DatamartMemberTuple_DatamartMemberTuple_2_0(context, (Expression) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getDatamartAdditionRule()
						|| action == grammarAccess.getDatamartAdditionAccess().getAdditionLeftAction_1_0_0_0()
						|| action == grammarAccess.getDatamartAdditionAccess().getSubtractionLeftAction_1_0_1_0()
						|| rule == grammarAccess.getDatamartMultiplicationRule()
						|| action == grammarAccess.getDatamartMultiplicationAccess().getMultiplicationLeftAction_1_0_0_0()
						|| action == grammarAccess.getDatamartMultiplicationAccess().getDivisionLeftAction_1_0_1_0()
						|| rule == grammarAccess.getDatamartPrimaryRule()
						|| rule == grammarAccess.getDatamartNumberOrElementRule()) {
					sequence_DatamartNumberOrElement(context, (Expression) semanticObject); 
					return; 
				}
				else if (action == grammarAccess.getDatamartSetAggregationAccess().getDatamartSetAggregationLeftAction_3_0()) {
					sequence_DatamartSetAggregation_DatamartSetAggregation_3_0(context, (Expression) semanticObject); 
					return; 
				}
				else if (action == grammarAccess.getDatamartSetTupleAccess().getDatamartSetTupleLeftAction_1_0()) {
					sequence_DatamartSetTuple_DatamartSetTuple_1_0(context, (Expression) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getDatamartDisjunctionRule()
						|| action == grammarAccess.getDatamartDisjunctionAccess().getDisjunctionLeftAction_1_0_0()
						|| rule == grammarAccess.getDatamartConjunctionRule()
						|| action == grammarAccess.getDatamartConjunctionAccess().getConjunctionLeftAction_1_0_0()
						|| rule == grammarAccess.getDatamartConditionalExpressionRule()
						|| action == grammarAccess.getDatamartConditionalExpressionAccess().getConditionalExpressionLeftAction_1_0_0()
						|| rule == grammarAccess.getDatamartOperandRule()
						|| rule == grammarAccess.getDatamartValueRule()) {
					sequence_DatamartValue(context, (Expression) semanticObject); 
					return; 
				}
				else break;
			case DatamartDSLPackage.MULTIPLICATION:
				sequence_DatamartMultiplication(context, (Multiplication) semanticObject); 
				return; 
			case DatamartDSLPackage.SUBTRACTION:
				sequence_DatamartAddition(context, (Subtraction) semanticObject); 
				return; 
			}
		else if (epackage == OXtypePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case OXtypePackage.OX_IMPORT_DECLARATION:
				sequence_XImportDeclaration(context, (OXImportDeclaration) semanticObject); 
				return; 
			}
		else if (epackage == TypesPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case TypesPackage.JVM_FORMAL_PARAMETER:
				if (rule == grammarAccess.getFullJvmFormalParameterRule()) {
					sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmFormalParameterRule()) {
					sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE:
				sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); 
				return; 
			case TypesPackage.JVM_INNER_TYPE_REFERENCE:
				sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); 
				return; 
			case TypesPackage.JVM_LOWER_BOUND:
				if (rule == grammarAccess.getJvmLowerBoundAndedRule()) {
					sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmLowerBoundRule()) {
					sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE:
				if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) {
					sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmTypeReferenceRule()
						|| action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()
						|| rule == grammarAccess.getJvmParameterizedTypeReferenceRule()
						|| rule == grammarAccess.getJvmArgumentTypeReferenceRule()) {
					sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_TYPE_PARAMETER:
				sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); 
				return; 
			case TypesPackage.JVM_UPPER_BOUND:
				if (rule == grammarAccess.getJvmUpperBoundAndedRule()) {
					sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getJvmUpperBoundRule()) {
					sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); 
					return; 
				}
				else break;
			case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE:
				sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); 
				return; 
			}
		else if (epackage == XAnnotationsPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XAnnotationsPackage.XANNOTATION:
				sequence_XAnnotation(context, (XAnnotation) semanticObject); 
				return; 
			case XAnnotationsPackage.XANNOTATION_ELEMENT_VALUE_PAIR:
				sequence_XAnnotationElementValuePair(context, (XAnnotationElementValuePair) semanticObject); 
				return; 
			}
		else if (epackage == XbasePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XbasePackage.XASSIGNMENT:
				sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); 
				return; 
			case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION:
				sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); 
				return; 
			case XbasePackage.XBINARY_OPERATION:
				sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); 
				return; 
			case XbasePackage.XBLOCK_EXPRESSION:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationElementValueRule()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXBlockExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XBlockExpression(context, (XBlockExpression) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXExpressionInClosureRule()) {
					sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XBOOLEAN_LITERAL:
				sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); 
				return; 
			case XbasePackage.XCASE_PART:
				sequence_XCasePart(context, (XCasePart) semanticObject); 
				return; 
			case XbasePackage.XCASTED_EXPRESSION:
				sequence_XCastedExpression(context, (XCastedExpression) semanticObject); 
				return; 
			case XbasePackage.XCATCH_CLAUSE:
				sequence_XCatchClause(context, (XCatchClause) semanticObject); 
				return; 
			case XbasePackage.XCLOSURE:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationElementValueRule()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXLiteralRule()
						|| rule == grammarAccess.getXClosureRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XClosure(context, (XClosure) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXShortClosureRule()) {
					sequence_XShortClosure(context, (XClosure) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XCONSTRUCTOR_CALL:
				sequence_XConstructorCall(context, (XConstructorCall) semanticObject); 
				return; 
			case XbasePackage.XDO_WHILE_EXPRESSION:
				sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); 
				return; 
			case XbasePackage.XFEATURE_CALL:
				sequence_XFeatureCall(context, (XFeatureCall) semanticObject); 
				return; 
			case XbasePackage.XFOR_LOOP_EXPRESSION:
				sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); 
				return; 
			case XbasePackage.XIF_EXPRESSION:
				sequence_XIfExpression(context, (XIfExpression) semanticObject); 
				return; 
			case XbasePackage.XINSTANCE_OF_EXPRESSION:
				sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); 
				return; 
			case XbasePackage.XLIST_LITERAL:
				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()) {
					sequence_XAnnotationElementValueOrCommaList_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else if (rule == grammarAccess.getXAnnotationElementValueRule()) {
					sequence_XAnnotationElementValue_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else if (action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
						|| rule == grammarAccess.getXExpressionRule()
						|| rule == grammarAccess.getXAssignmentRule()
						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOrExpressionRule()
						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAndExpressionRule()
						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXEqualityExpressionRule()
						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXRelationalExpressionRule()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXAdditiveExpressionRule()
						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
						|| rule == grammarAccess.getXUnaryOperationRule()
						|| rule == grammarAccess.getXCastedExpressionRule()
						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
						|| rule == grammarAccess.getXPostfixOperationRule()
						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
						|| rule == grammarAccess.getXMemberFeatureCallRule()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
						|| rule == grammarAccess.getXPrimaryExpressionRule()
						|| rule == grammarAccess.getXLiteralRule()
						|| rule == grammarAccess.getXCollectionLiteralRule()
						|| rule == grammarAccess.getXListLiteralRule()
						|| rule == grammarAccess.getXParenthesizedExpressionRule()
						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
					sequence_XListLiteral(context, (XListLiteral) semanticObject); 
					return; 
				}
				else break;
			case XbasePackage.XMEMBER_FEATURE_CALL:
				sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); 
				return; 
			case XbasePackage.XNULL_LITERAL:
				sequence_XNullLiteral(context, (XNullLiteral) semanticObject); 
				return; 
			case XbasePackage.XNUMBER_LITERAL:
				sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); 
				return; 
			case XbasePackage.XPOSTFIX_OPERATION:
				sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); 
				return; 
			case XbasePackage.XRETURN_EXPRESSION:
				sequence_XReturnExpression(context, (XReturnExpression) semanticObject); 
				return; 
			case XbasePackage.XSET_LITERAL:
				sequence_XSetLiteral(context, (XSetLiteral) semanticObject); 
				return; 
			case XbasePackage.XSTRING_LITERAL:
				sequence_XStringLiteral(context, (XStringLiteral) semanticObject); 
				return; 
			case XbasePackage.XSWITCH_EXPRESSION:
				sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); 
				return; 
			case XbasePackage.XSYNCHRONIZED_EXPRESSION:
				sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); 
				return; 
			case XbasePackage.XTHROW_EXPRESSION:
				sequence_XThrowExpression(context, (XThrowExpression) semanticObject); 
				return; 
			case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION:
				sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); 
				return; 
			case XbasePackage.XTYPE_LITERAL:
				sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); 
				return; 
			case XbasePackage.XUNARY_OPERATION:
				sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); 
				return; 
			case XbasePackage.XVARIABLE_DECLARATION:
				sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); 
				return; 
			case XbasePackage.XWHILE_EXPRESSION:
				sequence_XWhileExpression(context, (XWhileExpression) semanticObject); 
				return; 
			}
		else if (epackage == XtypePackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case XtypePackage.XFUNCTION_TYPE_REF:
				sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); 
				return; 
			case XtypePackage.XIMPORT_SECTION:
				sequence_XImportSection(context, (XImportSection) semanticObject); 
				return; 
			}
		if (errorAcceptor != null)
			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Contexts:
	 *     AttributeFillerData returns AttributeFillerData
	 *
	 * Constraint:
	 *     (attributeRef=[LEntityAttribute|ID] fillerType=AttributeFillerType)
	 */
	protected void sequence_AttributeFillerData(ISerializationContext context, AttributeFillerData semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATA__ATTRIBUTE_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATA__ATTRIBUTE_REF));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATA__FILLER_TYPE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATA__FILLER_TYPE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAttributeFillerDataAccess().getAttributeRefLEntityAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATA__ATTRIBUTE_REF, false));
		feeder.accept(grammarAccess.getAttributeFillerDataAccess().getFillerTypeAttributeFillerTypeParserRuleCall_3_0(), semanticObject.getFillerType());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerDateFuture
	 *     AttributeFillerDateFuture returns AttributeFillerDateFuture
	 *
	 * Constraint:
	 *     dateFutureYears=INT
	 */
	protected void sequence_AttributeFillerDateFuture(ISerializationContext context, AttributeFillerDateFuture semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_FUTURE__DATE_FUTURE_YEARS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_FUTURE__DATE_FUTURE_YEARS));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAttributeFillerDateFutureAccess().getDateFutureYearsINTTerminalRuleCall_1_0(), semanticObject.getDateFutureYears());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerDatePast
	 *     AttributeFillerDatePast returns AttributeFillerDatePast
	 *
	 * Constraint:
	 *     datePastYears=INT
	 */
	protected void sequence_AttributeFillerDatePast(ISerializationContext context, AttributeFillerDatePast semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_PAST__DATE_PAST_YEARS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_PAST__DATE_PAST_YEARS));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAttributeFillerDatePastAccess().getDatePastYearsINTTerminalRuleCall_1_0(), semanticObject.getDatePastYears());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerDateRange
	 *     AttributeFillerDateRange returns AttributeFillerDateRange
	 *
	 * Constraint:
	 *     (dateBeginYears=SINT dateEndYears=SINT)
	 */
	protected void sequence_AttributeFillerDateRange(ISerializationContext context, AttributeFillerDateRange semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_RANGE__DATE_BEGIN_YEARS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_RANGE__DATE_BEGIN_YEARS));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_RANGE__DATE_END_YEARS) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.ATTRIBUTE_FILLER_DATE_RANGE__DATE_END_YEARS));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getAttributeFillerDateRangeAccess().getDateBeginYearsSINTParserRuleCall_1_0(), semanticObject.getDateBeginYears());
		feeder.accept(grammarAccess.getAttributeFillerDateRangeAccess().getDateEndYearsSINTParserRuleCall_3_0(), semanticObject.getDateEndYears());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerSignedDoubleRandom
	 *     AttributeFillerSignedDoubleRandom returns AttributeFillerSignedDoubleRandom
	 *
	 * Constraint:
	 *     items+=SignedNumber+
	 */
	protected void sequence_AttributeFillerSignedDoubleRandom(ISerializationContext context, AttributeFillerSignedDoubleRandom semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerSignedDoubleRange
	 *     AttributeFillerSignedDoubleRange returns AttributeFillerSignedDoubleRange
	 *
	 * Constraint:
	 *     (
	 *         ((beginRange=SignedNumber | beginRangeRef=[LEntityAttribute|ID])? (endRange=SignedNumber | endRangeRef=[LEntityAttribute|ID]))? 
	 *         decimals=INT 
	 *         rounded=UnsignedNumber?
	 *     )
	 */
	protected void sequence_AttributeFillerSignedDoubleRange(ISerializationContext context, AttributeFillerSignedDoubleRange semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerSignedIntegerRandom
	 *     AttributeFillerSignedIntegerRandom returns AttributeFillerSignedIntegerRandom
	 *
	 * Constraint:
	 *     items+=SINT+
	 */
	protected void sequence_AttributeFillerSignedIntegerRandom(ISerializationContext context, AttributeFillerSignedIntegerRandom semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerSignedIntegerRange
	 *     AttributeFillerSignedIntegerRange returns AttributeFillerSignedIntegerRange
	 *
	 * Constraint:
	 *     (((beginRange=SINT | beginRangeRef=[LEntityAttribute|ID])? (endRange=SINT | endRangeRef=[LEntityAttribute|ID]))? rounded=INT?)
	 */
	protected void sequence_AttributeFillerSignedIntegerRange(ISerializationContext context, AttributeFillerSignedIntegerRange semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerTextParagraphs
	 *     AttributeFillerTextParagraphs returns AttributeFillerTextParagraphs
	 *
	 * Constraint:
	 *     count=INT?
	 */
	protected void sequence_AttributeFillerTextParagraphs(ISerializationContext context, AttributeFillerTextParagraphs semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerTextRandom
	 *     AttributeFillerTextRandom returns AttributeFillerTextRandom
	 *
	 * Constraint:
	 *     items+=STRING+
	 */
	protected void sequence_AttributeFillerTextRandom(ISerializationContext context, AttributeFillerTextRandom semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerTextSentences
	 *     AttributeFillerTextSentences returns AttributeFillerTextSentences
	 *
	 * Constraint:
	 *     count=INT?
	 */
	protected void sequence_AttributeFillerTextSentences(ISerializationContext context, AttributeFillerTextSentences semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerTextWords
	 *     AttributeFillerTextWords returns AttributeFillerTextWords
	 *
	 * Constraint:
	 *     count=INT?
	 */
	protected void sequence_AttributeFillerTextWords(ISerializationContext context, AttributeFillerTextWords semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerUnsignedDoubleRandom
	 *     AttributeFillerUnsignedDoubleRandom returns AttributeFillerUnsignedDoubleRandom
	 *
	 * Constraint:
	 *     items+=UnsignedNumber+
	 */
	protected void sequence_AttributeFillerUnsignedDoubleRandom(ISerializationContext context, AttributeFillerUnsignedDoubleRandom semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerUnsignedDoubleRange
	 *     AttributeFillerUnsignedDoubleRange returns AttributeFillerUnsignedDoubleRange
	 *
	 * Constraint:
	 *     (
	 *         ((beginRange=UnsignedNumber | beginRangeRef=[LEntityAttribute|ID])? (endRange=UnsignedNumber | endRangeRef=[LEntityAttribute|ID]))? 
	 *         decimals=INT 
	 *         rounded=UnsignedNumber?
	 *     )
	 */
	protected void sequence_AttributeFillerUnsignedDoubleRange(ISerializationContext context, AttributeFillerUnsignedDoubleRange semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerUnsignedIntegerRandom
	 *     AttributeFillerUnsignedIntegerRandom returns AttributeFillerUnsignedIntegerRandom
	 *
	 * Constraint:
	 *     items+=INT+
	 */
	protected void sequence_AttributeFillerUnsignedIntegerRandom(ISerializationContext context, AttributeFillerUnsignedIntegerRandom semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     AttributeFillerType returns AttributeFillerUnsignedIntegerRange
	 *     AttributeFillerUnsignedIntegerRange returns AttributeFillerUnsignedIntegerRange
	 *
	 * Constraint:
	 *     (((beginRange=INT | beginRangeRef=[LEntityAttribute|ID])? (endRange=INT | endRangeRef=[LEntityAttribute|ID]))? rounded=INT?)
	 */
	protected void sequence_AttributeFillerUnsignedIntegerRange(ISerializationContext context, AttributeFillerUnsignedIntegerRange semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns Addition
	 *     DatamartAddition.Addition_1_0_0_0 returns Addition
	 *     DatamartAddition.Subtraction_1_0_1_0 returns Addition
	 *     DatamartMultiplication returns Addition
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns Addition
	 *     DatamartMultiplication.Division_1_0_1_0 returns Addition
	 *     DatamartPrimary returns Addition
	 *
	 * Constraint:
	 *     (left=DatamartAddition_Addition_1_0_0_0 right=DatamartMultiplication)
	 */
	protected void sequence_DatamartAddition(ISerializationContext context, Addition semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAdditionAccess().getAdditionLeftAction_1_0_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartAdditionAccess().getRightDatamartMultiplicationParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns Subtraction
	 *     DatamartAddition.Addition_1_0_0_0 returns Subtraction
	 *     DatamartAddition.Subtraction_1_0_1_0 returns Subtraction
	 *     DatamartMultiplication returns Subtraction
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns Subtraction
	 *     DatamartMultiplication.Division_1_0_1_0 returns Subtraction
	 *     DatamartPrimary returns Subtraction
	 *
	 * Constraint:
	 *     (left=DatamartAddition_Subtraction_1_0_1_0 right=DatamartMultiplication)
	 */
	protected void sequence_DatamartAddition(ISerializationContext context, Subtraction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAdditionAccess().getSubtractionLeftAction_1_0_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartAdditionAccess().getRightDatamartMultiplicationParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAggregationFunction returns DatamartAggregationFunction
	 *
	 * Constraint:
	 *     aggregation=AggregationEnum
	 */
	protected void sequence_DatamartAggregationFunction(ISerializationContext context, DatamartAggregationFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_FUNCTION__AGGREGATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_FUNCTION__AGGREGATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAggregationFunctionAccess().getAggregationAggregationEnumEnumRuleCall_0(), semanticObject.getAggregation());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns DatamartAggregation
	 *     DatamartAddition.Addition_1_0_0_0 returns DatamartAggregation
	 *     DatamartAddition.Subtraction_1_0_1_0 returns DatamartAggregation
	 *     DatamartMultiplication returns DatamartAggregation
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns DatamartAggregation
	 *     DatamartMultiplication.Division_1_0_1_0 returns DatamartAggregation
	 *     DatamartPrimary returns DatamartAggregation
	 *     DatamartNumberOrElement returns DatamartAggregation
	 *     DatamartAggregation returns DatamartAggregation
	 *
	 * Constraint:
	 *     (left=DatamartAggregation_DatamartAggregation_3_0 right=DatamartMeasure)
	 */
	protected void sequence_DatamartAggregation(ISerializationContext context, DatamartAggregation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAggregationAccess().getDatamartAggregationLeftAction_3_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartAggregationAccess().getRightDatamartMeasureParserRuleCall_3_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAggregation.DatamartAggregation_3_0 returns Expression
	 *
	 * Constraint:
	 *     (aggregation=DatamartAggregationFunction (set=DatamartSetTuple | set=DatamartHierarchy))
	 */
	protected void sequence_DatamartAggregation_DatamartAggregation_3_0(ISerializationContext context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAttributeBase returns DatamartAttributeBase
	 *     DatamartDisjunction returns DatamartAttributeBase
	 *     DatamartDisjunction.Disjunction_1_0_0 returns DatamartAttributeBase
	 *     DatamartConjunction returns DatamartAttributeBase
	 *     DatamartConjunction.Conjunction_1_0_0 returns DatamartAttributeBase
	 *     DatamartConditionalExpression returns DatamartAttributeBase
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns DatamartAttributeBase
	 *     DatamartOperand returns DatamartAttributeBase
	 *     DatamartValue returns DatamartAttributeBase
	 *
	 * Constraint:
	 *     attributeRef=[LEntityAttribute|ID]
	 */
	protected void sequence_DatamartAttributeBase(ISerializationContext context, DatamartAttributeBase semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_ATTRIBUTE_BASE__ATTRIBUTE_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_ATTRIBUTE_BASE__ATTRIBUTE_REF));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAttributeBaseAccess().getAttributeRefLEntityAttributeIDTerminalRuleCall_1_0_1(), semanticObject.eGet(DatamartDSLPackage.Literals.DATAMART_ATTRIBUTE_BASE__ATTRIBUTE_REF, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAttribute returns DatamartAttribute
	 *
	 * Constraint:
	 *     (
	 *         attributeRef=[LEntityAttribute|ID] 
	 *         (aliased?='alias' aliasName=TRANSLATABLEID)? 
	 *         axis=DatamartAxis 
	 *         (hasColumnWeight?='columnWeight' columnWeight=INT)? 
	 *         ((aggregated?='aggregate' aggregate=SqlAggregationEnum) | (scaled?='scale' scale=ValueScaleEnum))*
	 *     )
	 */
	protected void sequence_DatamartAttribute(ISerializationContext context, DatamartAttribute semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAxis returns DatamartAxis
	 *
	 * Constraint:
	 *     name=AxisEnum
	 */
	protected void sequence_DatamartAxis(ISerializationContext context, DatamartAxis semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AXIS__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AXIS__NAME));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartAxisAccess().getNameAxisEnumEnumRuleCall_1_0(), semanticObject.getName());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartColumn returns DatamartColumn
	 *     DatamartDisjunction returns DatamartColumn
	 *     DatamartDisjunction.Disjunction_1_0_0 returns DatamartColumn
	 *     DatamartConjunction returns DatamartColumn
	 *     DatamartConjunction.Conjunction_1_0_0 returns DatamartColumn
	 *     DatamartConditionalExpression returns DatamartColumn
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns DatamartColumn
	 *     DatamartOperand returns DatamartColumn
	 *     DatamartValue returns DatamartColumn
	 *
	 * Constraint:
	 *     columnRef=TaskQueryColumnEnum
	 */
	protected void sequence_DatamartColumn(ISerializationContext context, DatamartColumn semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_COLUMN__COLUMN_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_COLUMN__COLUMN_REF));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartColumnAccess().getColumnRefTaskQueryColumnEnumEnumRuleCall_1_0(), semanticObject.getColumnRef());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartCondition returns DatamartCondition
	 *
	 * Constraint:
	 *     condition=DatamartDisjunction
	 */
	protected void sequence_DatamartCondition(ISerializationContext context, DatamartCondition semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_CONDITION__CONDITION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_CONDITION__CONDITION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartConditionAccess().getConditionDatamartDisjunctionParserRuleCall_1_0(), semanticObject.getCondition());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartDisjunction returns ConditionalExpression
	 *     DatamartDisjunction.Disjunction_1_0_0 returns ConditionalExpression
	 *     DatamartConjunction returns ConditionalExpression
	 *     DatamartConjunction.Conjunction_1_0_0 returns ConditionalExpression
	 *     DatamartConditionalExpression returns ConditionalExpression
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns ConditionalExpression
	 *     DatamartOperand returns ConditionalExpression
	 *
	 * Constraint:
	 *     (left=DatamartConditionalExpression_ConditionalExpression_1_0_0 operator=OperatorEnum right=DatamartOperand)
	 */
	protected void sequence_DatamartConditionalExpression(ISerializationContext context, ConditionalExpression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CONDITIONAL_EXPRESSION__OPERATOR) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CONDITIONAL_EXPRESSION__OPERATOR));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartConditionalExpressionAccess().getConditionalExpressionLeftAction_1_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartConditionalExpressionAccess().getOperatorOperatorEnumEnumRuleCall_1_0_1_0(), semanticObject.getOperator());
		feeder.accept(grammarAccess.getDatamartConditionalExpressionAccess().getRightDatamartOperandParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartDisjunction returns Conjunction
	 *     DatamartDisjunction.Disjunction_1_0_0 returns Conjunction
	 *     DatamartConjunction returns Conjunction
	 *     DatamartConjunction.Conjunction_1_0_0 returns Conjunction
	 *     DatamartConditionalExpression returns Conjunction
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns Conjunction
	 *     DatamartOperand returns Conjunction
	 *
	 * Constraint:
	 *     (left=DatamartConjunction_Conjunction_1_0_0 right=DatamartConditionalExpression)
	 */
	protected void sequence_DatamartConjunction(ISerializationContext context, Conjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartConjunctionAccess().getConjunctionLeftAction_1_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartConjunctionAccess().getRightDatamartConditionalExpressionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartCubeElement returns DatamartCubeAxis
	 *     DatamartCubeAxis returns DatamartCubeAxis
	 *
	 * Constraint:
	 *     (axis=DatamartAxis elements+=DatamartElement*)
	 */
	protected void sequence_DatamartCubeAxis(ISerializationContext context, DatamartCubeAxis semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSource returns DatamartCube
	 *     DatamartCube returns DatamartCube
	 *
	 * Constraint:
	 *     (cubeRef=[CubeType|ID] nonEmpty?='nonempty'? axisslicer+=DatamartCubeElement*)
	 */
	protected void sequence_DatamartCube(ISerializationContext context, DatamartCube semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartCubeElement returns DatamartDefineDerivedMeasure
	 *     DatamartDefineDerivedMeasure returns DatamartDefineDerivedMeasure
	 *
	 * Constraint:
	 *     (name=TRANSLATABLEID derivedElement+=DatamartAddition*)
	 */
	protected void sequence_DatamartDefineDerivedMeasure(ISerializationContext context, DatamartDefineDerivedMeasure semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartDefinition returns DatamartDefinition
	 *
	 * Constraint:
	 *     (name=ID (description?='description' descriptionValue=TRANSLATABLESTRING)? roles+=DatamartRole* source=DatamartSource)
	 */
	protected void sequence_DatamartDefinition(ISerializationContext context, DatamartDefinition semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns DatamartDerivedMeasure
	 *     DatamartAddition.Addition_1_0_0_0 returns DatamartDerivedMeasure
	 *     DatamartAddition.Subtraction_1_0_1_0 returns DatamartDerivedMeasure
	 *     DatamartMultiplication returns DatamartDerivedMeasure
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns DatamartDerivedMeasure
	 *     DatamartMultiplication.Division_1_0_1_0 returns DatamartDerivedMeasure
	 *     DatamartPrimary returns DatamartDerivedMeasure
	 *     DatamartNumberOrElement returns DatamartDerivedMeasure
	 *     DatamartElement returns DatamartDerivedMeasure
	 *     DatamartDerivedMeasure returns DatamartDerivedMeasure
	 *
	 * Constraint:
	 *     (derivedRef=[DatamartDefineDerivedMeasure|ID] (scaled?='scale' scale=ValueScaleEnum)?)
	 */
	protected void sequence_DatamartDerivedMeasure(ISerializationContext context, DatamartDerivedMeasure semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartDisjunction returns Disjunction
	 *     DatamartDisjunction.Disjunction_1_0_0 returns Disjunction
	 *     DatamartConjunction returns Disjunction
	 *     DatamartConjunction.Conjunction_1_0_0 returns Disjunction
	 *     DatamartConditionalExpression returns Disjunction
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns Disjunction
	 *     DatamartOperand returns Disjunction
	 *
	 * Constraint:
	 *     (left=DatamartDisjunction_Disjunction_1_0_0 right=DatamartConjunction)
	 */
	protected void sequence_DatamartDisjunction(ISerializationContext context, Disjunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartDisjunctionAccess().getDisjunctionLeftAction_1_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartDisjunctionAccess().getRightDatamartConjunctionParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSource returns DatamartEntity
	 *     DatamartEntity returns DatamartEntity
	 *
	 * Constraint:
	 *     (
	 *         entityRef=[LEntity|ID] 
	 *         tracking?='tracking'? 
	 *         navigations+=DatamartNavigation* 
	 *         attributes+=DatamartAttribute* 
	 *         conditions+=DatamartCondition* 
	 *         ordering+=DatamartOrder* 
	 *         (fillerMinCountRows=INT fillerMaxCountRows=INT fillerDatas+=AttributeFillerData*)?
	 *     )
	 */
	protected void sequence_DatamartEntity(ISerializationContext context, DatamartEntity semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartFunctionIntParameter returns DatamartFunctionIntParameter
	 *
	 * Constraint:
	 *     value=INT
	 */
	protected void sequence_DatamartFunctionIntParameter(ISerializationContext context, DatamartFunctionIntParameter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_FUNCTION_INT_PARAMETER__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_FUNCTION_INT_PARAMETER__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartFunctionIntParameterAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartFunction returns DatamartFunction
	 *
	 * Constraint:
	 *     function=FunctionEnum
	 */
	protected void sequence_DatamartFunction(ISerializationContext context, DatamartFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_FUNCTION__FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_FUNCTION__FUNCTION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartFunctionAccess().getFunctionFunctionEnumEnumRuleCall_0(), semanticObject.getFunction());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartElement returns DatamartHierarchy
	 *     DatamartHierarchy returns DatamartHierarchy
	 *
	 * Constraint:
	 *     (
	 *         hierarchyRef=[CubeHierarchy|ID] 
	 *         defaultMember?='default'? 
	 *         allMember?='condensed'? 
	 *         allLevels?='exploded'? 
	 *         (levelRef=[CubeLevel|ID] (filtered?='filtered' | selected?='selected')?)? 
	 *         (
	 *             all?='detailed' 
	 *             (except?='except' exceptRef=[CubeLevel|ID])? 
	 *             (ordered?='orderby' (orderRef=DatamartMeasure | orderRef=DatamartDerivedMeasure) descending?='descending'?)?
	 *         )?
	 *     )
	 */
	protected void sequence_DatamartHierarchy(ISerializationContext context, DatamartHierarchy semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns DatamartMeasure
	 *     DatamartAddition.Addition_1_0_0_0 returns DatamartMeasure
	 *     DatamartAddition.Subtraction_1_0_1_0 returns DatamartMeasure
	 *     DatamartMultiplication returns DatamartMeasure
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns DatamartMeasure
	 *     DatamartMultiplication.Division_1_0_1_0 returns DatamartMeasure
	 *     DatamartPrimary returns DatamartMeasure
	 *     DatamartNumberOrElement returns DatamartMeasure
	 *     DatamartElement returns DatamartMeasure
	 *     DatamartMeasure returns DatamartMeasure
	 *
	 * Constraint:
	 *     (measureRef=[CubeMeasure|ID] (scaled?='scale' scale=ValueScaleEnum)?)
	 */
	protected void sequence_DatamartMeasure(ISerializationContext context, DatamartMeasure semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns DatamartMemberTuple
	 *     DatamartAddition.Addition_1_0_0_0 returns DatamartMemberTuple
	 *     DatamartAddition.Subtraction_1_0_1_0 returns DatamartMemberTuple
	 *     DatamartMultiplication returns DatamartMemberTuple
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns DatamartMemberTuple
	 *     DatamartMultiplication.Division_1_0_1_0 returns DatamartMemberTuple
	 *     DatamartPrimary returns DatamartMemberTuple
	 *     DatamartNumberOrElement returns DatamartMemberTuple
	 *     DatamartMemberTuple returns DatamartMemberTuple
	 *
	 * Constraint:
	 *     (left=DatamartMemberTuple_DatamartMemberTuple_2_0 right=DatamartMeasure)
	 */
	protected void sequence_DatamartMemberTuple(ISerializationContext context, DatamartMemberTuple semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartMemberTupleAccess().getDatamartMemberTupleLeftAction_2_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartMemberTupleAccess().getRightDatamartMeasureParserRuleCall_2_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartMemberTuple.DatamartMemberTuple_2_0 returns Expression
	 *
	 * Constraint:
	 *     ((function=DatamartFunction | function=DatamartParameterFunction)? hierarchy=DatamartHierarchy)
	 */
	protected void sequence_DatamartMemberTuple_DatamartMemberTuple_2_0(ISerializationContext context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartNavigation returns DatamartMember
	 *     DatamartMember returns DatamartMember
	 *
	 * Constraint:
	 *     (joinRef=DatamartReference datamartEntity=DatamartEntity)
	 */
	protected void sequence_DatamartMember(ISerializationContext context, DatamartMember semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__JOIN_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__JOIN_REF));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__DATAMART_ENTITY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__DATAMART_ENTITY));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartMemberAccess().getJoinRefDatamartReferenceParserRuleCall_1_0(), semanticObject.getJoinRef());
		feeder.accept(grammarAccess.getDatamartMemberAccess().getDatamartEntityDatamartEntityParserRuleCall_3_0(), semanticObject.getDatamartEntity());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartModel returns DatamartModel
	 *
	 * Constraint:
	 *     ((importSection=XImportSection packages+=DatamartPackage+) | packages+=DatamartPackage+)?
	 */
	protected void sequence_DatamartModel(ISerializationContext context, DatamartModel semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns Division
	 *     DatamartAddition.Addition_1_0_0_0 returns Division
	 *     DatamartAddition.Subtraction_1_0_1_0 returns Division
	 *     DatamartMultiplication returns Division
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns Division
	 *     DatamartMultiplication.Division_1_0_1_0 returns Division
	 *     DatamartPrimary returns Division
	 *
	 * Constraint:
	 *     (left=DatamartMultiplication_Division_1_0_1_0 right=DatamartPrimary)
	 */
	protected void sequence_DatamartMultiplication(ISerializationContext context, Division semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartMultiplicationAccess().getDivisionLeftAction_1_0_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartMultiplicationAccess().getRightDatamartPrimaryParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns Multiplication
	 *     DatamartAddition.Addition_1_0_0_0 returns Multiplication
	 *     DatamartAddition.Subtraction_1_0_1_0 returns Multiplication
	 *     DatamartMultiplication returns Multiplication
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns Multiplication
	 *     DatamartMultiplication.Division_1_0_1_0 returns Multiplication
	 *     DatamartPrimary returns Multiplication
	 *
	 * Constraint:
	 *     (left=DatamartMultiplication_Multiplication_1_0_0_0 right=DatamartPrimary)
	 */
	protected void sequence_DatamartMultiplication(ISerializationContext context, Multiplication semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.CALCULATION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartMultiplicationAccess().getMultiplicationLeftAction_1_0_0_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartMultiplicationAccess().getRightDatamartPrimaryParserRuleCall_1_1_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartAddition returns Expression
	 *     DatamartAddition.Addition_1_0_0_0 returns Expression
	 *     DatamartAddition.Subtraction_1_0_1_0 returns Expression
	 *     DatamartMultiplication returns Expression
	 *     DatamartMultiplication.Multiplication_1_0_0_0 returns Expression
	 *     DatamartMultiplication.Division_1_0_1_0 returns Expression
	 *     DatamartPrimary returns Expression
	 *     DatamartNumberOrElement returns Expression
	 *
	 * Constraint:
	 *     value=Number
	 */
	protected void sequence_DatamartNumberOrElement(ISerializationContext context, Expression semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.EXPRESSION__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.EXPRESSION__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartNumberOrElementAccess().getValueNumberParserRuleCall_0_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartOrder returns DatamartOrder
	 *
	 * Constraint:
	 *     (orderBy=[LEntityAttribute|ID] orderHow=OrderEnum (hasColumnWeight?='columnWeight' columnWeight=INT)?)
	 */
	protected void sequence_DatamartOrder(ISerializationContext context, DatamartOrder semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartNavigation returns DatamartOwner
	 *     DatamartOwner returns DatamartOwner
	 *
	 * Constraint:
	 *     (joinRef=DatamartReference datamartEntity=DatamartEntity)
	 */
	protected void sequence_DatamartOwner(ISerializationContext context, DatamartOwner semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__JOIN_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__JOIN_REF));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__DATAMART_ENTITY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_NAVIGATION__DATAMART_ENTITY));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartOwnerAccess().getJoinRefDatamartReferenceParserRuleCall_1_0(), semanticObject.getJoinRef());
		feeder.accept(grammarAccess.getDatamartOwnerAccess().getDatamartEntityDatamartEntityParserRuleCall_3_0(), semanticObject.getDatamartEntity());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartPackage returns DatamartPackage
	 *
	 * Constraint:
	 *     (name=QualifiedName definitions+=DatamartDefinition*)
	 */
	protected void sequence_DatamartPackage(ISerializationContext context, DatamartPackage semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartParameterFunction returns DatamartParameterFunction
	 *
	 * Constraint:
	 *     (function=ParameterFunctionEnum parameter=DatamartFunctionIntParameter)
	 */
	protected void sequence_DatamartParameterFunction(ISerializationContext context, DatamartParameterFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_PARAMETER_FUNCTION__FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_PARAMETER_FUNCTION__FUNCTION));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_PARAMETER_FUNCTION__PARAMETER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_PARAMETER_FUNCTION__PARAMETER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartParameterFunctionAccess().getFunctionParameterFunctionEnumEnumRuleCall_0_0(), semanticObject.getFunction());
		feeder.accept(grammarAccess.getDatamartParameterFunctionAccess().getParameterDatamartFunctionIntParameterParserRuleCall_2_0(), semanticObject.getParameter());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartReference returns DatamartReference
	 *
	 * Constraint:
	 *     ref=[LEntityReference|ID]
	 */
	protected void sequence_DatamartReference(ISerializationContext context, DatamartReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_REFERENCE__REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_REFERENCE__REF));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartReferenceAccess().getRefLEntityReferenceIDTerminalRuleCall_1_0_1(), semanticObject.eGet(DatamartDSLPackage.Literals.DATAMART_REFERENCE__REF, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartRole returns DatamartRole
	 *
	 * Constraint:
	 *     assignedRole=[Role|ID]
	 */
	protected void sequence_DatamartRole(ISerializationContext context, DatamartRole semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_ROLE__ASSIGNED_ROLE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_ROLE__ASSIGNED_ROLE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartRoleAccess().getAssignedRoleRoleIDTerminalRuleCall_1_0_1(), semanticObject.eGet(DatamartDSLPackage.Literals.DATAMART_ROLE__ASSIGNED_ROLE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetAggregationFunction returns DatamartSetAggregationFunction
	 *
	 * Constraint:
	 *     (aggregation=SetAggregationEnum parameter=DatamartFunctionIntParameter)
	 */
	protected void sequence_DatamartSetAggregationFunction(ISerializationContext context, DatamartSetAggregationFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_AGGREGATION_FUNCTION__AGGREGATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_AGGREGATION_FUNCTION__AGGREGATION));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_AGGREGATION_FUNCTION__PARAMETER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_AGGREGATION_FUNCTION__PARAMETER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSetAggregationFunctionAccess().getAggregationSetAggregationEnumEnumRuleCall_0_0(), semanticObject.getAggregation());
		feeder.accept(grammarAccess.getDatamartSetAggregationFunctionAccess().getParameterDatamartFunctionIntParameterParserRuleCall_2_0(), semanticObject.getParameter());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetAggregation returns DatamartSetAggregation
	 *     DatamartElement returns DatamartSetAggregation
	 *
	 * Constraint:
	 *     (left=DatamartSetAggregation_DatamartSetAggregation_3_0 right=DatamartMeasure)
	 */
	protected void sequence_DatamartSetAggregation(ISerializationContext context, DatamartSetAggregation semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_AGGREGATION_EXPRESSION__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSetAggregationAccess().getDatamartSetAggregationLeftAction_3_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartSetAggregationAccess().getRightDatamartMeasureParserRuleCall_3_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetAggregation.DatamartSetAggregation_3_0 returns Expression
	 *
	 * Constraint:
	 *     (aggregation=DatamartSetAggregationFunction (set=DatamartSetTuple | set=DatamartHierarchy))
	 */
	protected void sequence_DatamartSetAggregation_DatamartSetAggregation_3_0(ISerializationContext context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetFunction returns DatamartSetFunction
	 *
	 * Constraint:
	 *     setFunction=SetFunctionEnum
	 */
	protected void sequence_DatamartSetFunction(ISerializationContext context, DatamartSetFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_FUNCTION__SET_FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_FUNCTION__SET_FUNCTION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSetFunctionAccess().getSetFunctionSetFunctionEnumEnumRuleCall_0(), semanticObject.getSetFunction());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetParameterFunction returns DatamartSetParameterFunction
	 *
	 * Constraint:
	 *     (setFunction=SetParameterFunctionEnum parameter=DatamartFunctionIntParameter)
	 */
	protected void sequence_DatamartSetParameterFunction(ISerializationContext context, DatamartSetParameterFunction semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_PARAMETER_FUNCTION__SET_FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_PARAMETER_FUNCTION__SET_FUNCTION));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_PARAMETER_FUNCTION__PARAMETER) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_PARAMETER_FUNCTION__PARAMETER));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSetParameterFunctionAccess().getSetFunctionSetParameterFunctionEnumEnumRuleCall_0_0(), semanticObject.getSetFunction());
		feeder.accept(grammarAccess.getDatamartSetParameterFunctionAccess().getParameterDatamartFunctionIntParameterParserRuleCall_2_0(), semanticObject.getParameter());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetTuple returns DatamartSetTuple
	 *
	 * Constraint:
	 *     (left=DatamartSetTuple_DatamartSetTuple_1_0 right=DatamartHierarchy)
	 */
	protected void sequence_DatamartSetTuple(ISerializationContext context, DatamartSetTuple semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_TUPLE__LEFT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_TUPLE__LEFT));
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_TUPLE__RIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SET_TUPLE__RIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSetTupleAccess().getDatamartSetTupleLeftAction_1_0(), semanticObject.getLeft());
		feeder.accept(grammarAccess.getDatamartSetTupleAccess().getRightDatamartHierarchyParserRuleCall_1_2_0(), semanticObject.getRight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSetTuple.DatamartSetTuple_1_0 returns Expression
	 *
	 * Constraint:
	 *     (setFunction=DatamartSetFunction | setFunction=DatamartSetParameterFunction)
	 */
	protected void sequence_DatamartSetTuple_DatamartSetTuple_1_0(ISerializationContext context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartCubeElement returns DatamartSlicer
	 *     DatamartSlicer returns DatamartSlicer
	 *
	 * Constraint:
	 *     element=DatamartElement
	 */
	protected void sequence_DatamartSlicer(ISerializationContext context, DatamartSlicer semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_SLICER__ELEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_SLICER__ELEMENT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartSlicerAccess().getElementDatamartElementParserRuleCall_1_0(), semanticObject.getElement());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartTaskFilter returns DatamartTaskFilter
	 *     DatamartDisjunction returns DatamartTaskFilter
	 *     DatamartDisjunction.Disjunction_1_0_0 returns DatamartTaskFilter
	 *     DatamartConjunction returns DatamartTaskFilter
	 *     DatamartConjunction.Conjunction_1_0_0 returns DatamartTaskFilter
	 *     DatamartConditionalExpression returns DatamartTaskFilter
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns DatamartTaskFilter
	 *     DatamartOperand returns DatamartTaskFilter
	 *     DatamartValue returns DatamartTaskFilter
	 *
	 * Constraint:
	 *     filterRef=TaskFilterEnum
	 */
	protected void sequence_DatamartTaskFilter(ISerializationContext context, DatamartTaskFilter semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, DatamartDSLPackage.Literals.DATAMART_TASK_FILTER__FILTER_REF) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DatamartDSLPackage.Literals.DATAMART_TASK_FILTER__FILTER_REF));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDatamartTaskFilterAccess().getFilterRefTaskFilterEnumEnumRuleCall_1_0(), semanticObject.getFilterRef());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     DatamartSource returns DatamartTask
	 *     DatamartTask returns DatamartTask
	 *
	 * Constraint:
	 *     (taskQuery=TaskQueryTopicEnum columns+=DatamartColumn* conditions+=DatamartCondition*)
	 */
	protected void sequence_DatamartTask(ISerializationContext context, DatamartTask semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     DatamartDisjunction returns Expression
	 *     DatamartDisjunction.Disjunction_1_0_0 returns Expression
	 *     DatamartConjunction returns Expression
	 *     DatamartConjunction.Conjunction_1_0_0 returns Expression
	 *     DatamartConditionalExpression returns Expression
	 *     DatamartConditionalExpression.ConditionalExpression_1_0_0 returns Expression
	 *     DatamartOperand returns Expression
	 *     DatamartValue returns Expression
	 *
	 * Constraint:
	 *     (numberValue=Number | stringValue=STRING | (filtered?='filtered' optional?='optional'?) | selected?='selected' | ranged?='ranged')
	 */
	protected void sequence_DatamartValue(ISerializationContext context, Expression semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
}