path: root/Application/hu.bme.mit.inf.dslreasoner.application/src-gen/hu/bme/mit/inf/dslreasoner/application/serializer/ApplicationConfigurationSemanticSequencer.java

/*
 * generated by Xtext 2.21.0
 */
package hu.bme.mit.inf.dslreasoner.application.serializer;

import com.google.inject.Inject;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassTypeScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.CostEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.CostObjectiveFunction;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.CustomEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.DocumentationEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ExactNumber;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FileDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FileReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FileSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FolderEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GenerationTask;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GraphPatternDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.GraphPatternReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntEnumberation;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntegerScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntegerTypeScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.IntervallNumber;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MemoryEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ModelEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectTypeScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectiveDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectiveReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ObjectiveSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.OptimizationEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PartialModelSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RealEnumeration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RealScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RealTypeScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.RuntimeEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeDeclaration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeReference;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ScopeSpecification;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.StringEnumeration;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.StringScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.StringTypeScope;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ThresholdEntry;
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport;
import hu.bme.mit.inf.dslreasoner.application.services.ApplicationConfigurationGrammarAccess;
import java.util.Set;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EPackage;
import org.eclipse.xtext.Action;
import org.eclipse.xtext.Parameter;
import org.eclipse.xtext.ParserRule;
import org.eclipse.xtext.serializer.ISerializationContext;
import org.eclipse.xtext.serializer.acceptor.SequenceFeeder;
import org.eclipse.xtext.serializer.sequencer.AbstractDelegatingSemanticSequencer;
import org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient;

@SuppressWarnings("all")
public class ApplicationConfigurationSemanticSequencer extends AbstractDelegatingSemanticSequencer {

	@Inject
	private ApplicationConfigurationGrammarAccess 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 == ApplicationConfigurationPackage.eINSTANCE)
			switch (semanticObject.eClass().getClassifierID()) {
			case ApplicationConfigurationPackage.ALL_PACKAGE_ENTRY:
				sequence_AllPackageEntry(context, (AllPackageEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.ALL_PATTERN_ENTRY:
				sequence_AllPatternEntry(context, (AllPatternEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CLASS_REFERENCE:
				sequence_ClassReference(context, (ClassReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CLASS_TYPE_SCOPE:
				sequence_ClassTypeScope(context, (ClassTypeScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CONFIG_DECLARATION:
				sequence_ConfigDeclaration(context, (ConfigDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CONFIG_REFERENCE:
				sequence_ConfigReference(context, (ConfigReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CONFIG_SPECIFICATION:
				sequence_ConfigSpecification(context, (ConfigSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CONFIGURATION_SCRIPT:
				sequence_ConfigurationScript(context, (ConfigurationScript) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.COST_ENTRY:
				sequence_CostEntry(context, (CostEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.COST_OBJECTIVE_FUNCTION:
				sequence_CostObjectiveFunction(context, (CostObjectiveFunction) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.CUSTOM_ENTRY:
				sequence_CustomEntry(context, (CustomEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.DOCUMENTATION_ENTRY:
				sequence_DocumentationEntry(context, (DocumentationEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.EPACKAGE_IMPORT:
				sequence_EPackageImport(context, (EPackageImport) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.EXACT_NUMBER:
				sequence_ExactNumber(context, (ExactNumber) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.FILE_DECLARATION:
				sequence_FileDeclaration(context, (FileDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.FILE_REFERENCE:
				sequence_FileReference(context, (FileReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.FILE_SPECIFICATION:
				sequence_FileSpecification(context, (FileSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.FOLDER_ENTRY:
				sequence_FolderEntry(context, (FolderEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.GENERATION_TASK:
				sequence_GenerationTask(context, (GenerationTask) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.GRAPH_PATTERN_DECLARATION:
				sequence_GraphPatternDeclaration(context, (GraphPatternDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.GRAPH_PATTERN_REFERENCE:
				sequence_GraphPatternReference(context, (GraphPatternReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.INT_ENUMBERATION:
				sequence_IntEnumberation(context, (IntEnumberation) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.INTEGER_SCOPE:
				sequence_IntegerReference(context, (IntegerScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.INTEGER_TYPE_SCOPE:
				sequence_IntegerTypeScope(context, (IntegerTypeScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.INTERVALL_NUMBER:
				sequence_IntervallNumber(context, (IntervallNumber) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.MEMORY_ENTRY:
				sequence_MemoryEntry(context, (MemoryEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.METAMODEL_DECLARATION:
				sequence_MetamodelDeclaration(context, (MetamodelDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.METAMODEL_ELEMENT:
				sequence_MetamodelElement(context, (MetamodelElement) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.METAMODEL_REFERENCE:
				sequence_MetamodelReference(context, (MetamodelReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.METAMODEL_SPECIFICATION:
				sequence_MetamodelSpecification(context, (MetamodelSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.MODEL_ENTRY:
				sequence_ModelEntry(context, (ModelEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OBJECT_REFERENCE:
				sequence_ObjectReference(context, (ObjectReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OBJECT_TYPE_SCOPE:
				sequence_ObjectTypeScope(context, (ObjectTypeScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OBJECTIVE_DECLARATION:
				sequence_ObjectiveDeclaration(context, (ObjectiveDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OBJECTIVE_REFERENCE:
				sequence_ObjectiveReference(context, (ObjectiveReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OBJECTIVE_SPECIFICATION:
				sequence_ObjectiveSpecification(context, (ObjectiveSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.OPTIMIZATION_ENTRY:
				sequence_OptimizationEntry(context, (OptimizationEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.PARTIAL_MODEL_DECLARATION:
				sequence_PartialModelDeclaration(context, (PartialModelDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.PARTIAL_MODEL_REFERENCE:
				sequence_PartialModelReference(context, (PartialModelReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.PARTIAL_MODEL_SPECIFICATION:
				sequence_PartialModelSpecification(context, (PartialModelSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.PATTERN_ELEMENT:
				sequence_PatternElement(context, (PatternElement) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.PATTERN_SPECIFICATION:
				sequence_PatternSpecification(context, (PatternSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.REAL_ENUMERATION:
				sequence_RealEnumeration(context, (RealEnumeration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.REAL_SCOPE:
				sequence_RealReference(context, (RealScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.REAL_TYPE_SCOPE:
				sequence_RealTypeScope(context, (RealTypeScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.RUNTIME_ENTRY:
				sequence_RuntimeEntry(context, (RuntimeEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.SCOPE_DECLARATION:
				sequence_ScopeDeclaration(context, (ScopeDeclaration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.SCOPE_REFERENCE:
				sequence_ScopeReference(context, (ScopeReference) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.SCOPE_SPECIFICATION:
				sequence_ScopeSpecification(context, (ScopeSpecification) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.STRING_ENUMERATION:
				sequence_StringEnumeration(context, (StringEnumeration) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.STRING_SCOPE:
				sequence_StringReference(context, (StringScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.STRING_TYPE_SCOPE:
				sequence_StringTypeScope(context, (StringTypeScope) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.THRESHOLD_ENTRY:
				sequence_ThresholdEntry(context, (ThresholdEntry) semanticObject); 
				return; 
			case ApplicationConfigurationPackage.VIATRA_IMPORT:
				sequence_ViatraImport(context, (ViatraImport) semanticObject); 
				return; 
			}
		if (errorAcceptor != null)
			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
	}
	
	/**
	 * Contexts:
	 *     MetamodelEntry returns AllPackageEntry
	 *     AllPackageEntry returns AllPackageEntry
	 *
	 * Constraint:
	 *     (package=[EPackage|QualifiedName] (exclusion+=MetamodelElement exclusion+=MetamodelElement*)?)
	 */
	protected void sequence_AllPackageEntry(ISerializationContext context, AllPackageEntry semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PatternEntry returns AllPatternEntry
	 *     AllPatternEntry returns AllPatternEntry
	 *
	 * Constraint:
	 *     (package=[PatternModel|QualifiedName] (exclusuion+=PatternElement exclusuion+=PatternElement*)?)
	 */
	protected void sequence_AllPatternEntry(ISerializationContext context, AllPatternEntry semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeReference returns ClassReference
	 *     ClassReference returns ClassReference
	 *
	 * Constraint:
	 *     element=MetamodelElement
	 */
	protected void sequence_ClassReference(ISerializationContext context, ClassReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.CLASS_REFERENCE__ELEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.CLASS_REFERENCE__ELEMENT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getClassReferenceAccess().getElementMetamodelElementParserRuleCall_1_0(), semanticObject.getElement());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     TypeScope returns ClassTypeScope
	 *     ClassTypeScope returns ClassTypeScope
	 *
	 * Constraint:
	 *     (type=ClassReference (setsNew?='+=' | setsSum?='=') (number=ExactNumber | number=IntervallNumber))
	 */
	protected void sequence_ClassTypeScope(ISerializationContext context, ClassTypeScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Command returns ConfigDeclaration
	 *     Declaration returns ConfigDeclaration
	 *     ConfigDeclaration returns ConfigDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=ConfigSpecification)
	 */
	protected void sequence_ConfigDeclaration(ISerializationContext context, ConfigDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.CONFIG_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.CONFIG_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConfigDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getConfigDeclarationAccess().getSpecificationConfigSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ConfigReference returns ConfigReference
	 *     Config returns ConfigReference
	 *
	 * Constraint:
	 *     config=[ConfigDeclaration|ID]
	 */
	protected void sequence_ConfigReference(ISerializationContext context, ConfigReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.CONFIG_REFERENCE__CONFIG) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.CONFIG_REFERENCE__CONFIG));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getConfigReferenceAccess().getConfigConfigDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.CONFIG_REFERENCE__CONFIG, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ConfigSpecification returns ConfigSpecification
	 *     Config returns ConfigSpecification
	 *
	 * Constraint:
	 *     (entries+=ConfigEntry entries+=ConfigEntry*)?
	 */
	protected void sequence_ConfigSpecification(ISerializationContext context, ConfigSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ConfigurationScript returns ConfigurationScript
	 *
	 * Constraint:
	 *     ((imports+=Import+ commands+=Command+) | commands+=Command+)?
	 */
	protected void sequence_ConfigurationScript(ISerializationContext context, ConfigurationScript semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     CostEntry returns CostEntry
	 *
	 * Constraint:
	 *     (patternElement=PatternElement weight=INTLiteral)
	 */
	protected void sequence_CostEntry(ISerializationContext context, CostEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.COST_ENTRY__PATTERN_ELEMENT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.COST_ENTRY__PATTERN_ELEMENT));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.COST_ENTRY__WEIGHT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.COST_ENTRY__WEIGHT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getCostEntryAccess().getPatternElementPatternElementParserRuleCall_0_0(), semanticObject.getPatternElement());
		feeder.accept(grammarAccess.getCostEntryAccess().getWeightINTLiteralParserRuleCall_2_0(), semanticObject.getWeight());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ObjectiveFunction returns CostObjectiveFunction
	 *     CostObjectiveFunction returns CostObjectiveFunction
	 *
	 * Constraint:
	 *     (entries+=CostEntry entries+=CostEntry*)
	 */
	protected void sequence_CostObjectiveFunction(ISerializationContext context, CostObjectiveFunction semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ConfigEntry returns CustomEntry
	 *     CustomEntry returns CustomEntry
	 *
	 * Constraint:
	 *     (key=STRING value=STRING)
	 */
	protected void sequence_CustomEntry(ISerializationContext context, CustomEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.CUSTOM_ENTRY__KEY) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.CUSTOM_ENTRY__KEY));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.CUSTOM_ENTRY__VALUE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.CUSTOM_ENTRY__VALUE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getCustomEntryAccess().getKeySTRINGTerminalRuleCall_0_0(), semanticObject.getKey());
		feeder.accept(grammarAccess.getCustomEntryAccess().getValueSTRINGTerminalRuleCall_2_0(), semanticObject.getValue());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ConfigEntry returns DocumentationEntry
	 *     DocumentationEntry returns DocumentationEntry
	 *
	 * Constraint:
	 *     level=DocumentLevelSpecification
	 */
	protected void sequence_DocumentationEntry(ISerializationContext context, DocumentationEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DOCUMENTATION_ENTRY__LEVEL) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DOCUMENTATION_ENTRY__LEVEL));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getDocumentationEntryAccess().getLevelDocumentLevelSpecificationEnumRuleCall_2_0(), semanticObject.getLevel());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Import returns EPackageImport
	 *     EPackageImport returns EPackageImport
	 *
	 * Constraint:
	 *     importedPackage=[EPackage|STRING]
	 */
	protected void sequence_EPackageImport(ISerializationContext context, EPackageImport semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.EPACKAGE_IMPORT__IMPORTED_PACKAGE) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.EPACKAGE_IMPORT__IMPORTED_PACKAGE));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getEPackageImportAccess().getImportedPackageEPackageSTRINGTerminalRuleCall_2_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.EPACKAGE_IMPORT__IMPORTED_PACKAGE, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NumberSpecification returns ExactNumber
	 *     ExactNumber returns ExactNumber
	 *
	 * Constraint:
	 *     (exactNumber=INT | exactUnlimited?='*')
	 */
	protected void sequence_ExactNumber(ISerializationContext context, ExactNumber semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Command returns FileDeclaration
	 *     Declaration returns FileDeclaration
	 *     FileDeclaration returns FileDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=FileSpecification)
	 */
	protected void sequence_FileDeclaration(ISerializationContext context, FileDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.FILE_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.FILE_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFileDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getFileDeclarationAccess().getSpecificationFileSpecificationParserRuleCall_3_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FileReference returns FileReference
	 *     File returns FileReference
	 *
	 * Constraint:
	 *     referred=[FileDeclaration|ID]
	 */
	protected void sequence_FileReference(ISerializationContext context, FileReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.FILE_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.FILE_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFileReferenceAccess().getReferredFileDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.FILE_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     FileSpecification returns FileSpecification
	 *     File returns FileSpecification
	 *
	 * Constraint:
	 *     path=STRING
	 */
	protected void sequence_FileSpecification(ISerializationContext context, FileSpecification semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.FILE_SPECIFICATION__PATH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.FILE_SPECIFICATION__PATH));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getFileSpecificationAccess().getPathSTRINGTerminalRuleCall_0(), semanticObject.getPath());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PartialModelEntry returns FolderEntry
	 *     FolderEntry returns FolderEntry
	 *
	 * Constraint:
	 *     (path=File (exclusion+=ModelEntry exclusion+=ModelEntry*)?)
	 */
	protected void sequence_FolderEntry(ISerializationContext context, FolderEntry semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Command returns GenerationTask
	 *     Task returns GenerationTask
	 *     GenerationTask returns GenerationTask
	 *
	 * Constraint:
	 *     (
	 *         (
	 *             metamodel=Metamodel | 
	 *             partialModel=PartialModel | 
	 *             patterns=GraphPattern | 
	 *             objectives=Objective | 
	 *             scope=Scope | 
	 *             solver=Solver | 
	 *             config=Config | 
	 *             debugFolder=File | 
	 *             targetLogFile=File | 
	 *             targetStatisticsFile=File | 
	 *             tagetFolder=File
	 *         )? 
	 *         (numberSpecified?='number' number=INT)? 
	 *         (runSpecified?='runs' runs=INT)?
	 *     )+
	 */
	protected void sequence_GenerationTask(ISerializationContext context, GenerationTask semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Command returns GraphPatternDeclaration
	 *     Declaration returns GraphPatternDeclaration
	 *     GraphPatternDeclaration returns GraphPatternDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=PatternSpecification)
	 */
	protected void sequence_GraphPatternDeclaration(ISerializationContext context, GraphPatternDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.GRAPH_PATTERN_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.GRAPH_PATTERN_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getGraphPatternDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getGraphPatternDeclarationAccess().getSpecificationPatternSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     GraphPatternReference returns GraphPatternReference
	 *     GraphPattern returns GraphPatternReference
	 *
	 * Constraint:
	 *     referred=[GraphPatternDeclaration|ID]
	 */
	protected void sequence_GraphPatternReference(ISerializationContext context, GraphPatternReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.GRAPH_PATTERN_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.GRAPH_PATTERN_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getGraphPatternReferenceAccess().getReferredGraphPatternDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.GRAPH_PATTERN_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     NumberSpecification returns IntEnumberation
	 *     IntEnumberation returns IntEnumberation
	 *
	 * Constraint:
	 *     (entry+=INTLiteral entry+=INTLiteral*)?
	 */
	protected void sequence_IntEnumberation(ISerializationContext context, IntEnumberation semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeReference returns IntegerScope
	 *     IntegerReference returns IntegerScope
	 *
	 * Constraint:
	 *     {IntegerScope}
	 */
	protected void sequence_IntegerReference(ISerializationContext context, IntegerScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeScope returns IntegerTypeScope
	 *     IntegerTypeScope returns IntegerTypeScope
	 *
	 * Constraint:
	 *     (type=IntegerReference (setsNew?='+=' | setsSum?='=') (number=ExactNumber | number=IntervallNumber | number=IntEnumberation))
	 */
	protected void sequence_IntegerTypeScope(ISerializationContext context, IntegerTypeScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NumberSpecification returns IntervallNumber
	 *     IntervallNumber returns IntervallNumber
	 *
	 * Constraint:
	 *     (min=INT (maxNumber=INT | maxUnlimited?='*'))
	 */
	protected void sequence_IntervallNumber(ISerializationContext context, IntervallNumber semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ConfigEntry returns MemoryEntry
	 *     MemoryEntry returns MemoryEntry
	 *
	 * Constraint:
	 *     megabyteLimit=INT
	 */
	protected void sequence_MemoryEntry(ISerializationContext context, MemoryEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.MEMORY_ENTRY__MEGABYTE_LIMIT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.MEMORY_ENTRY__MEGABYTE_LIMIT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getMemoryEntryAccess().getMegabyteLimitINTTerminalRuleCall_2_0(), semanticObject.getMegabyteLimit());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Command returns MetamodelDeclaration
	 *     Declaration returns MetamodelDeclaration
	 *     MetamodelDeclaration returns MetamodelDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=MetamodelSpecification)
	 */
	protected void sequence_MetamodelDeclaration(ISerializationContext context, MetamodelDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.METAMODEL_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.METAMODEL_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getMetamodelDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getMetamodelDeclarationAccess().getSpecificationMetamodelSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     MetamodelEntry returns MetamodelElement
	 *     MetamodelElement returns MetamodelElement
	 *
	 * Constraint:
	 *     (package=[EPackage|QualifiedName]? classifier=[EClassifier|ID] feature=[ENamedElement|ID]?)
	 */
	protected void sequence_MetamodelElement(ISerializationContext context, MetamodelElement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     MetamodelReference returns MetamodelReference
	 *     Metamodel returns MetamodelReference
	 *
	 * Constraint:
	 *     referred=[MetamodelDeclaration|ID]
	 */
	protected void sequence_MetamodelReference(ISerializationContext context, MetamodelReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.METAMODEL_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.METAMODEL_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getMetamodelReferenceAccess().getReferredMetamodelDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.METAMODEL_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     MetamodelSpecification returns MetamodelSpecification
	 *     Metamodel returns MetamodelSpecification
	 *
	 * Constraint:
	 *     (entries+=MetamodelEntry entries+=MetamodelEntry*)
	 */
	protected void sequence_MetamodelSpecification(ISerializationContext context, MetamodelSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PartialModelEntry returns ModelEntry
	 *     ModelEntry returns ModelEntry
	 *
	 * Constraint:
	 *     path=File
	 */
	protected void sequence_ModelEntry(ISerializationContext context, ModelEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_ENTRY__PATH) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_ENTRY__PATH));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getModelEntryAccess().getPathFileParserRuleCall_0(), semanticObject.getPath());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     TypeReference returns ObjectReference
	 *     ObjectReference returns ObjectReference
	 *
	 * Constraint:
	 *     {ObjectReference}
	 */
	protected void sequence_ObjectReference(ISerializationContext context, ObjectReference semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeScope returns ObjectTypeScope
	 *     ObjectTypeScope returns ObjectTypeScope
	 *
	 * Constraint:
	 *     (type=ObjectReference (setsNew?='+=' | setsSum?='=') (number=ExactNumber | number=IntervallNumber))
	 */
	protected void sequence_ObjectTypeScope(ISerializationContext context, ObjectTypeScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     Command returns ObjectiveDeclaration
	 *     Declaration returns ObjectiveDeclaration
	 *     ObjectiveDeclaration returns ObjectiveDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=ObjectiveSpecification)
	 */
	protected void sequence_ObjectiveDeclaration(ISerializationContext context, ObjectiveDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getObjectiveDeclarationAccess().getSpecificationObjectiveSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ObjectiveReference returns ObjectiveReference
	 *     Objective returns ObjectiveReference
	 *
	 * Constraint:
	 *     referred=[ObjectiveDeclaration|ID]
	 */
	protected void sequence_ObjectiveReference(ISerializationContext context, ObjectiveReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getObjectiveReferenceAccess().getReferredObjectiveDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.OBJECTIVE_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ObjectiveSpecification returns ObjectiveSpecification
	 *     Objective returns ObjectiveSpecification
	 *
	 * Constraint:
	 *     (entries+=ObjectiveEntry entries+=ObjectiveEntry*)
	 */
	protected void sequence_ObjectiveSpecification(ISerializationContext context, ObjectiveSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ObjectiveEntry returns OptimizationEntry
	 *     OptimizationEntry returns OptimizationEntry
	 *
	 * Constraint:
	 *     (direction=OptimizationDirection function=ObjectiveFunction)
	 */
	protected void sequence_OptimizationEntry(ISerializationContext context, OptimizationEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.OPTIMIZATION_ENTRY__DIRECTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.OPTIMIZATION_ENTRY__DIRECTION));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_ENTRY__FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_ENTRY__FUNCTION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getOptimizationEntryAccess().getDirectionOptimizationDirectionEnumRuleCall_0_0(), semanticObject.getDirection());
		feeder.accept(grammarAccess.getOptimizationEntryAccess().getFunctionObjectiveFunctionParserRuleCall_1_0(), semanticObject.getFunction());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Command returns PartialModelDeclaration
	 *     Declaration returns PartialModelDeclaration
	 *     PartialModelDeclaration returns PartialModelDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=PartialModelSpecification)
	 */
	protected void sequence_PartialModelDeclaration(ISerializationContext context, PartialModelDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPartialModelDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getPartialModelDeclarationAccess().getSpecificationPartialModelSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PartialModelReference returns PartialModelReference
	 *     PartialModel returns PartialModelReference
	 *
	 * Constraint:
	 *     referred=[PartialModelDeclaration|ID]
	 */
	protected void sequence_PartialModelReference(ISerializationContext context, PartialModelReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getPartialModelReferenceAccess().getReferredPartialModelDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.PARTIAL_MODEL_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     PartialModelSpecification returns PartialModelSpecification
	 *     PartialModel returns PartialModelSpecification
	 *
	 * Constraint:
	 *     (entry+=PartialModelEntry entry+=PartialModelEntry?)
	 */
	protected void sequence_PartialModelSpecification(ISerializationContext context, PartialModelSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PatternEntry returns PatternElement
	 *     PatternElement returns PatternElement
	 *
	 * Constraint:
	 *     (package=[PatternModel|QualifiedName]? pattern=[Pattern|ID])
	 */
	protected void sequence_PatternElement(ISerializationContext context, PatternElement semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     PatternSpecification returns PatternSpecification
	 *     GraphPattern returns PatternSpecification
	 *
	 * Constraint:
	 *     (entries+=PatternEntry entries+=PatternEntry*)
	 */
	protected void sequence_PatternSpecification(ISerializationContext context, PatternSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NumberSpecification returns RealEnumeration
	 *     RealEnumeration returns RealEnumeration
	 *
	 * Constraint:
	 *     (entry+=REALLiteral entry+=REALLiteral*)?
	 */
	protected void sequence_RealEnumeration(ISerializationContext context, RealEnumeration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeReference returns RealScope
	 *     RealReference returns RealScope
	 *
	 * Constraint:
	 *     {RealScope}
	 */
	protected void sequence_RealReference(ISerializationContext context, RealScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeScope returns RealTypeScope
	 *     RealTypeScope returns RealTypeScope
	 *
	 * Constraint:
	 *     (type=RealReference (setsNew?='+=' | setsSum?='=') (number=ExactNumber | number=IntervallNumber | number=RealEnumeration))
	 */
	protected void sequence_RealTypeScope(ISerializationContext context, RealTypeScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ConfigEntry returns RuntimeEntry
	 *     RuntimeEntry returns RuntimeEntry
	 *
	 * Constraint:
	 *     millisecLimit=INT
	 */
	protected void sequence_RuntimeEntry(ISerializationContext context, RuntimeEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.RUNTIME_ENTRY__MILLISEC_LIMIT) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.RUNTIME_ENTRY__MILLISEC_LIMIT));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getRuntimeEntryAccess().getMillisecLimitINTTerminalRuleCall_2_0(), semanticObject.getMillisecLimit());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Command returns ScopeDeclaration
	 *     Declaration returns ScopeDeclaration
	 *     ScopeDeclaration returns ScopeDeclaration
	 *
	 * Constraint:
	 *     (name=ID specification=ScopeSpecification)
	 */
	protected void sequence_ScopeDeclaration(ISerializationContext context, ScopeDeclaration semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.DECLARATION__NAME));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.SCOPE_DECLARATION__SPECIFICATION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.SCOPE_DECLARATION__SPECIFICATION));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getScopeDeclarationAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
		feeder.accept(grammarAccess.getScopeDeclarationAccess().getSpecificationScopeSpecificationParserRuleCall_2_0(), semanticObject.getSpecification());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ScopeReference returns ScopeReference
	 *     Scope returns ScopeReference
	 *
	 * Constraint:
	 *     referred=[ScopeDeclaration|ID]
	 */
	protected void sequence_ScopeReference(ISerializationContext context, ScopeReference semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.SCOPE_REFERENCE__REFERRED) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.SCOPE_REFERENCE__REFERRED));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getScopeReferenceAccess().getReferredScopeDeclarationIDTerminalRuleCall_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.SCOPE_REFERENCE__REFERRED, false));
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     ScopeSpecification returns ScopeSpecification
	 *     Scope returns ScopeSpecification
	 *
	 * Constraint:
	 *     (scopes+=TypeScope scopes+=TypeScope*)?
	 */
	protected void sequence_ScopeSpecification(ISerializationContext context, ScopeSpecification semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     NumberSpecification returns StringEnumeration
	 *     StringEnumeration returns StringEnumeration
	 *
	 * Constraint:
	 *     (entry+=STRING entry+=STRING*)?
	 */
	protected void sequence_StringEnumeration(ISerializationContext context, StringEnumeration semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeReference returns StringScope
	 *     StringReference returns StringScope
	 *
	 * Constraint:
	 *     {StringScope}
	 */
	protected void sequence_StringReference(ISerializationContext context, StringScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     TypeScope returns StringTypeScope
	 *     StringTypeScope returns StringTypeScope
	 *
	 * Constraint:
	 *     (type=StringReference (setsNew?='+=' | setsSum?='=') (number=ExactNumber | number=IntervallNumber | number=StringEnumeration))
	 */
	protected void sequence_StringTypeScope(ISerializationContext context, StringTypeScope semanticObject) {
		genericSequencer.createSequence(context, semanticObject);
	}
	
	
	/**
	 * Contexts:
	 *     ObjectiveEntry returns ThresholdEntry
	 *     ThresholdEntry returns ThresholdEntry
	 *
	 * Constraint:
	 *     (function=ObjectiveFunction operator=ComparisonOperator threshold=REALLiteral)
	 */
	protected void sequence_ThresholdEntry(ISerializationContext context, ThresholdEntry semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_ENTRY__FUNCTION) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.OBJECTIVE_ENTRY__FUNCTION));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.THRESHOLD_ENTRY__OPERATOR) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.THRESHOLD_ENTRY__OPERATOR));
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.THRESHOLD_ENTRY__THRESHOLD) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.THRESHOLD_ENTRY__THRESHOLD));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getThresholdEntryAccess().getFunctionObjectiveFunctionParserRuleCall_0_0(), semanticObject.getFunction());
		feeder.accept(grammarAccess.getThresholdEntryAccess().getOperatorComparisonOperatorEnumRuleCall_1_0(), semanticObject.getOperator());
		feeder.accept(grammarAccess.getThresholdEntryAccess().getThresholdREALLiteralParserRuleCall_2_0(), semanticObject.getThreshold());
		feeder.finish();
	}
	
	
	/**
	 * Contexts:
	 *     Import returns ViatraImport
	 *     ViatraImport returns ViatraImport
	 *
	 * Constraint:
	 *     importedViatra=[PatternModel|STRING]
	 */
	protected void sequence_ViatraImport(ISerializationContext context, ViatraImport semanticObject) {
		if (errorAcceptor != null) {
			if (transientValues.isValueTransient(semanticObject, ApplicationConfigurationPackage.Literals.VIATRA_IMPORT__IMPORTED_VIATRA) == ValueTransient.YES)
				errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, ApplicationConfigurationPackage.Literals.VIATRA_IMPORT__IMPORTED_VIATRA));
		}
		SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
		feeder.accept(grammarAccess.getViatraImportAccess().getImportedViatraPatternModelSTRINGTerminalRuleCall_2_0_1(), semanticObject.eGet(ApplicationConfigurationPackage.Literals.VIATRA_IMPORT__IMPORTED_VIATRA, false));
		feeder.finish();
	}
	
	
}