Java 类org.eclipse.xtext.serializer.sequencer.ITransientValueService.ValueTransient 实例源码

/**
 * Contexts:
 *     Card returns Card
 *
 * Constraint:
 *     (count=INT name=NAMESTRING setNr=INT set=NAMESTRING)
 */
protected void sequence_Card(ISerializationContext context, Card semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, PkmntcgoPackage.Literals.CARD__COUNT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PkmntcgoPackage.Literals.CARD__COUNT));
        if (transientValues.isValueTransient(semanticObject, PkmntcgoPackage.Literals.CARD__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PkmntcgoPackage.Literals.CARD__NAME));
        if (transientValues.isValueTransient(semanticObject, PkmntcgoPackage.Literals.CARD__SET_NR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PkmntcgoPackage.Literals.CARD__SET_NR));
        if (transientValues.isValueTransient(semanticObject, PkmntcgoPackage.Literals.CARD__SET) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, PkmntcgoPackage.Literals.CARD__SET));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getCardAccess().getCountINTTerminalRuleCall_0_0(), semanticObject.getCount());
    feeder.accept(grammarAccess.getCardAccess().getNameNAMESTRINGParserRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getCardAccess().getSetNrINTTerminalRuleCall_2_0(), semanticObject.getSetNr());
    feeder.accept(grammarAccess.getCardAccess().getSetNAMESTRINGParserRuleCall_3_0(), semanticObject.getSet());
    feeder.finish();
}

/**
 * Contexts:
 *     GExpression returns GAndExpression
 *     GOrExpression returns GAndExpression
 *     GOrExpression.GOrExpression_1_0 returns GAndExpression
 *     GXorExpression returns GAndExpression
 *     GXorExpression.GXorExpression_1_0 returns GAndExpression
 *     GAndExpression returns GAndExpression
 *     GAndExpression.GAndExpression_1_0 returns GAndExpression
 *
 * Constraint:
 *     (leftOperand=GAndExpression_GAndExpression_1_0 operator=GAndOperator rightOperand=GEqualityExpression)
 */
protected void sequence_GAndExpression(ISerializationContext context, GAndExpression semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GAND_EXPRESSION__OPERATOR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GAND_EXPRESSION__OPERATOR));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getGAndExpressionAccess().getGAndExpressionLeftOperandAction_1_0(), semanticObject.getLeftOperand());
    feeder.accept(grammarAccess.getGAndExpressionAccess().getOperatorGAndOperatorEnumRuleCall_1_1_0(), semanticObject.getOperator());
    feeder.accept(grammarAccess.getGAndExpressionAccess().getRightOperandGEqualityExpressionParserRuleCall_1_2_0(), semanticObject.getRightOperand());
    feeder.finish();
}

/**
 * Contexts:
 *     Button returns Button
 *
 * Constraint:
 *     (name=ID title=Description href=STRING)
 */
protected void sequence_Button(ISerializationContext context, Button semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.BUTTON__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.BUTTON__NAME));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.BUTTON__TITLE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.BUTTON__TITLE));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.BUTTON__HREF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.BUTTON__HREF));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getButtonAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getButtonAccess().getTitleDescriptionParserRuleCall_3_0(), semanticObject.getTitle());
    feeder.accept(grammarAccess.getButtonAccess().getHrefSTRINGTerminalRuleCall_5_0(), semanticObject.getHref());
    feeder.finish();
}

/**
 * Contexts:
 *     Link returns Link
 *
 * Constraint:
 *     (name=ID description=Description url=STRING)
 */
protected void sequence_Link(ISerializationContext context, Link semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.LINK__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.LINK__NAME));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.LINK__DESCRIPTION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.LINK__DESCRIPTION));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.LINK__URL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.LINK__URL));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getLinkAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getLinkAccess().getDescriptionDescriptionParserRuleCall_3_0(), semanticObject.getDescription());
    feeder.accept(grammarAccess.getLinkAccess().getUrlSTRINGTerminalRuleCall_5_0(), semanticObject.getUrl());
    feeder.finish();
}

/**
 * Contexts:
 *     Menu returns Menu
 *
 * Constraint:
 *     (name=ID meal=STRING description=Description price=STRING image=STRING)
 */
protected void sequence_Menu(ISerializationContext context, Menu semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.MENU__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.MENU__NAME));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.MENU__MEAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.MENU__MEAL));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.MENU__DESCRIPTION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.MENU__DESCRIPTION));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.MENU__PRICE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.MENU__PRICE));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.MENU__IMAGE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.MENU__IMAGE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getMenuAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getMenuAccess().getMealSTRINGTerminalRuleCall_4_0(), semanticObject.getMeal());
    feeder.accept(grammarAccess.getMenuAccess().getDescriptionDescriptionParserRuleCall_5_0(), semanticObject.getDescription());
    feeder.accept(grammarAccess.getMenuAccess().getPriceSTRINGTerminalRuleCall_7_0(), semanticObject.getPrice());
    feeder.accept(grammarAccess.getMenuAccess().getImageSTRINGTerminalRuleCall_9_0(), semanticObject.getImage());
    feeder.finish();
}

/**
 * Contexts:
 *     NAV returns NAV
 *
 * Constraint:
 *     (name=ID description=Description href=STRING)
 */
protected void sequence_NAV(ISerializationContext context, NAV semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.NAV__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.NAV__NAME));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.NAV__DESCRIPTION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.NAV__DESCRIPTION));
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.NAV__HREF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.NAV__HREF));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getNAVAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getNAVAccess().getDescriptionDescriptionParserRuleCall_3_0(), semanticObject.getDescription());
    feeder.accept(grammarAccess.getNAVAccess().getHrefSTRINGTerminalRuleCall_5_0(), semanticObject.getHref());
    feeder.finish();
}

/**
 * Contexts:
 *     ThreeDottedVersion returns ThreeDottedVersion
 *
 * Constraint:
 *     (big=INT medium=INT small=INT)
 */
protected void sequence_ThreeDottedVersion(ISerializationContext context, ThreeDottedVersion semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__BIG) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__BIG));
        if (transientValues.isValueTransient(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__MEDIUM) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__MEDIUM));
        if (transientValues.isValueTransient(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__SMALL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BromiumPackage.Literals.THREE_DOTTED_VERSION__SMALL));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getThreeDottedVersionAccess().getBigINTTerminalRuleCall_0_0(), semanticObject.getBig());
    feeder.accept(grammarAccess.getThreeDottedVersionAccess().getMediumINTTerminalRuleCall_2_0(), semanticObject.getMedium());
    feeder.accept(grammarAccess.getThreeDottedVersionAccess().getSmallINTTerminalRuleCall_4_0(), semanticObject.getSmall());
    feeder.finish();
}

/**
 * Contexts:
 *     GExpression returns GEqualityExpression
 *     GOrExpression returns GEqualityExpression
 *     GOrExpression.GOrExpression_1_0 returns GEqualityExpression
 *     GXorExpression returns GEqualityExpression
 *     GXorExpression.GXorExpression_1_0 returns GEqualityExpression
 *     GAndExpression returns GEqualityExpression
 *     GAndExpression.GAndExpression_1_0 returns GEqualityExpression
 *     GEqualityExpression returns GEqualityExpression
 *     GEqualityExpression.GEqualityExpression_1_0 returns GEqualityExpression
 *
 * Constraint:
 *     (leftOperand=GEqualityExpression_GEqualityExpression_1_0 operator=GEqualityOperator rightOperand=GRelationExpression)
 */
protected void sequence_GEqualityExpression(ISerializationContext context, GEqualityExpression semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GEQUALITY_EXPRESSION__OPERATOR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GEQUALITY_EXPRESSION__OPERATOR));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getGEqualityExpressionAccess().getGEqualityExpressionLeftOperandAction_1_0(), semanticObject.getLeftOperand());
    feeder.accept(grammarAccess.getGEqualityExpressionAccess().getOperatorGEqualityOperatorEnumRuleCall_1_1_0(), semanticObject.getOperator());
    feeder.accept(grammarAccess.getGEqualityExpressionAccess().getRightOperandGRelationExpressionParserRuleCall_1_2_0(), semanticObject.getRightOperand());
    feeder.finish();
}

/**
 * Contexts:
 *     GExpression returns GOrExpression
 *     GOrExpression returns GOrExpression
 *     GOrExpression.GOrExpression_1_0 returns GOrExpression
 *
 * Constraint:
 *     (leftOperand=GOrExpression_GOrExpression_1_0 operator=GOrOperator rightOperand=GXorExpression)
 */
protected void sequence_GOrExpression(ISerializationContext context, GOrExpression semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__LEFT_OPERAND));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GOR_EXPRESSION__OPERATOR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GOR_EXPRESSION__OPERATOR));
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GBINARY_OPERATOR_EXPRESSION__RIGHT_OPERAND));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getGOrExpressionAccess().getGOrExpressionLeftOperandAction_1_0(), semanticObject.getLeftOperand());
    feeder.accept(grammarAccess.getGOrExpressionAccess().getOperatorGOrOperatorEnumRuleCall_1_1_0(), semanticObject.getOperator());
    feeder.accept(grammarAccess.getGOrExpressionAccess().getRightOperandGXorExpressionParserRuleCall_1_2_0(), semanticObject.getRightOperand());
    feeder.finish();
}

/**
 * Contexts:
 *     Type returns AnyType
 *     AnyType returns AnyType
 *
 * Constraint:
 *     name='any'
 */
protected void sequence_AnyType(ISerializationContext context, AnyType semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getAnyTypeAccess().getNameAnyKeyword_1_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     Type returns NullType
 *     NullType returns NullType
 *
 * Constraint:
 *     name='null'
 */
protected void sequence_NullType(ISerializationContext context, NullType semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getNullTypeAccess().getNameNullKeyword_1_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     TAnnotationArgument returns TAnnotationStringArgument
 *     TAnnotationStringArgument returns TAnnotationStringArgument
 *
 * Constraint:
 *     value=STRING
 */
protected void sequence_TAnnotationStringArgument(ISerializationContext context, TAnnotationStringArgument semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.TANNOTATION_STRING_ARGUMENT__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.TANNOTATION_STRING_ARGUMENT__VALUE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTAnnotationStringArgumentAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
    feeder.finish();
}

/**
 * Contexts:
 *     TAnnotationArgument returns TAnnotationTypeRefArgument
 *     TAnnotationTypeRefArgument returns TAnnotationTypeRefArgument
 *
 * Constraint:
 *     typeRef=TypeRef
 */
protected void sequence_TAnnotationTypeRefArgument(ISerializationContext context, TAnnotationTypeRefArgument semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.TTYPED_ELEMENT__TYPE_REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.TTYPED_ELEMENT__TYPE_REF));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTAnnotationTypeRefArgumentAccess().getTypeRefTypeRefParserRuleCall_0(), semanticObject.getTypeRef());
    feeder.finish();
}

/**
 * Contexts:
 *     TEnumLiteral returns TEnumLiteral
 *
 * Constraint:
 *     name=IDENTIFIER
 */
protected void sequence_TEnumLiteral(ISerializationContext context, TEnumLiteral semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTEnumLiteralAccess().getNameIDENTIFIERTerminalRuleCall_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     Type returns UndefinedType
 *     UndefinedType returns UndefinedType
 *
 * Constraint:
 *     name='undefined'
 */
protected void sequence_UndefinedType(ISerializationContext context, UndefinedType semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getUndefinedTypeAccess().getNameUndefinedKeyword_1_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     GImportStatement returns GImportStatement
 *
 * Constraint:
 *     importURI=STRING
 */
protected void sequence_GImportStatement(ISerializationContext context, GImportStatement semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, GexpressionsPackage.Literals.GIMPORT_STATEMENT__IMPORT_URI) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, GexpressionsPackage.Literals.GIMPORT_STATEMENT__IMPORT_URI));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getGImportStatementAccess().getImportURISTRINGTerminalRuleCall_1_0(), semanticObject.getImportURI());
    feeder.finish();
}

/**
 * Contexts:
 *     CharacterClassElement returns CharacterClassRange
 *
 * Constraint:
 *     (left=CharacterClassElement_CharacterClassRange_1_0_0 right=CharacterClassAtom)
 */
protected void sequence_CharacterClassElement(ISerializationContext context, CharacterClassRange semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, RegularExpressionPackage.Literals.CHARACTER_CLASS_RANGE__LEFT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RegularExpressionPackage.Literals.CHARACTER_CLASS_RANGE__LEFT));
        if (transientValues.isValueTransient(semanticObject, RegularExpressionPackage.Literals.CHARACTER_CLASS_RANGE__RIGHT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RegularExpressionPackage.Literals.CHARACTER_CLASS_RANGE__RIGHT));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getCharacterClassElementAccess().getCharacterClassRangeLeftAction_1_0_0(), semanticObject.getLeft());
    feeder.accept(grammarAccess.getCharacterClassElementAccess().getRightCharacterClassAtomParserRuleCall_1_0_2_0(), semanticObject.getRight());
    feeder.finish();
}

/**
 * Contexts:
 *     Nutricional returns Nutricional
 *
 * Constraint:
 *     (
 *         cantidad=Float 
 *         unidad=STRING 
 *         energia=Float 
 *         grasas=Float 
 *         hidratos=Float 
 *         proteinas=Float 
 *         sal=Float
 *     )
 */
protected void sequence_Nutricional(ISerializationContext context, Nutricional semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__CANTIDAD) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__CANTIDAD));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__UNIDAD) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__UNIDAD));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__ENERGIA) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__ENERGIA));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__GRASAS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__GRASAS));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__HIDRATOS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__HIDRATOS));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__PROTEINAS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__PROTEINAS));
        if (transientValues.isValueTransient(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__SAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RestaurantePackage.Literals.NUTRICIONAL__SAL));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getNutricionalAccess().getCantidadFloatParserRuleCall_2_0(), semanticObject.getCantidad());
    feeder.accept(grammarAccess.getNutricionalAccess().getUnidadSTRINGTerminalRuleCall_4_0(), semanticObject.getUnidad());
    feeder.accept(grammarAccess.getNutricionalAccess().getEnergiaFloatParserRuleCall_6_0(), semanticObject.getEnergia());
    feeder.accept(grammarAccess.getNutricionalAccess().getGrasasFloatParserRuleCall_8_0(), semanticObject.getGrasas());
    feeder.accept(grammarAccess.getNutricionalAccess().getHidratosFloatParserRuleCall_10_0(), semanticObject.getHidratos());
    feeder.accept(grammarAccess.getNutricionalAccess().getProteinasFloatParserRuleCall_12_0(), semanticObject.getProteinas());
    feeder.accept(grammarAccess.getNutricionalAccess().getSalFloatParserRuleCall_14_0(), semanticObject.getSal());
    feeder.finish();
}

/**
 * Contexts:
 *     RegularExpressionBody returns RegularExpressionBody
 *
 * Constraint:
 *     pattern=Disjunction
 */
protected void sequence_RegularExpressionBody(ISerializationContext context, RegularExpressionBody semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_BODY__PATTERN) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_BODY__PATTERN));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getRegularExpressionBodyAccess().getPatternDisjunctionParserRuleCall_0(), semanticObject.getPattern());
    feeder.finish();
}

/**
 * Contexts:
 *     RegularExpressionLiteral returns RegularExpressionLiteral
 *
 * Constraint:
 *     (body=RegularExpressionBody flags=RegularExpressionFlags)
 */
protected void sequence_RegularExpressionLiteral(ISerializationContext context, RegularExpressionLiteral semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_LITERAL__BODY) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_LITERAL__BODY));
        if (transientValues.isValueTransient(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_LITERAL__FLAGS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, RegularExpressionPackage.Literals.REGULAR_EXPRESSION_LITERAL__FLAGS));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getRegularExpressionLiteralAccess().getBodyRegularExpressionBodyParserRuleCall_1_0(), semanticObject.getBody());
    feeder.accept(grammarAccess.getRegularExpressionLiteralAccess().getFlagsRegularExpressionFlagsParserRuleCall_3_0(), semanticObject.getFlags());
    feeder.finish();
}

/**
 * Contexts:
 *     AssignmentExpressionStatement<In> returns ExpressionStatement
 *     AssignmentExpressionStatement returns ExpressionStatement
 *
 * Constraint:
 *     expression=AssignmentExpression
 */
protected void sequence_AssignmentExpressionStatement(ISerializationContext context, ExpressionStatement semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.EXPRESSION_STATEMENT__EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.EXPRESSION_STATEMENT__EXPRESSION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getAssignmentExpressionStatementAccess().getExpressionAssignmentExpressionParserRuleCall_0(), semanticObject.getExpression());
    feeder.finish();
}

/**
 * Contexts:
 *     BindingIdentifierAsFormalParameter<Yield> returns FormalParameter
 *     BindingIdentifierAsFormalParameter returns FormalParameter
 *
 * Constraint:
 *     name=BindingIdentifier
 */
protected void sequence_BindingIdentifierAsFormalParameter(ISerializationContext context, FormalParameter semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, TypesPackage.Literals.IDENTIFIABLE_ELEMENT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getBindingIdentifierAsFormalParameterAccess().getNameBindingIdentifierParserRuleCall_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     CatchBlock<Yield> returns CatchBlock
 *     CatchBlock returns CatchBlock
 *
 * Constraint:
 *     (catchVariable=CatchVariable block=Block)
 */
protected void sequence_CatchBlock(ISerializationContext context, CatchBlock semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.CATCH_BLOCK__CATCH_VARIABLE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.CATCH_BLOCK__CATCH_VARIABLE));
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.ABSTRACT_CATCH_BLOCK__BLOCK) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.ABSTRACT_CATCH_BLOCK__BLOCK));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getCatchBlockAccess().getCatchVariableCatchVariableParserRuleCall_3_0(), semanticObject.getCatchVariable());
    feeder.accept(grammarAccess.getCatchBlockAccess().getBlockBlockParserRuleCall_5_0(), semanticObject.getBlock());
    feeder.finish();
}

/**
 * Contexts:
 *     DefaultImportSpecifier returns DefaultImportSpecifier
 *
 * Constraint:
 *     importedElement=[TExportableElement|BindingIdentifier]
 */
protected void sequence_DefaultImportSpecifier(ISerializationContext context, DefaultImportSpecifier semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.NAMED_IMPORT_SPECIFIER__IMPORTED_ELEMENT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.NAMED_IMPORT_SPECIFIER__IMPORTED_ELEMENT));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getDefaultImportSpecifierAccess().getImportedElementTExportableElementBindingIdentifierParserRuleCall_0_1(), semanticObject.eGet(N4JSPackage.Literals.NAMED_IMPORT_SPECIFIER__IMPORTED_ELEMENT, false));
    feeder.finish();
}

/**
 * Contexts:
 *     FinallyBlock<Yield> returns FinallyBlock
 *     FinallyBlock returns FinallyBlock
 *
 * Constraint:
 *     block=Block
 */
protected void sequence_FinallyBlock(ISerializationContext context, FinallyBlock semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.ABSTRACT_CATCH_BLOCK__BLOCK) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.ABSTRACT_CATCH_BLOCK__BLOCK));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getFinallyBlockAccess().getBlockBlockParserRuleCall_2_0(), semanticObject.getBlock());
    feeder.finish();
}

/**
 * Contexts:
 *     JSXElementName returns JSXElementName
 *
 * Constraint:
 *     expression=JSXElementNameExpression
 */
protected void sequence_JSXElementName(ISerializationContext context, JSXElementName semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.JSX_ELEMENT_NAME__EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.JSX_ELEMENT_NAME__EXPRESSION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getJSXElementNameAccess().getExpressionJSXElementNameExpressionParserRuleCall_0(), semanticObject.getExpression());
    feeder.finish();
}

/**
 * Contexts:
 *     JSXChild returns JSXExpression
 *     JSXExpression returns JSXExpression
 *
 * Constraint:
 *     expression=AssignmentExpression
 */
protected void sequence_JSXExpression(ISerializationContext context, JSXExpression semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.JSX_EXPRESSION__EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.JSX_EXPRESSION__EXPRESSION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getJSXExpressionAccess().getExpressionAssignmentExpressionParserRuleCall_1_0(), semanticObject.getExpression());
    feeder.finish();
}

/**
 * Contexts:
 *     JSXAttribute returns JSXSpreadAttribute
 *     JSXSpreadAttribute returns JSXSpreadAttribute
 *
 * Constraint:
 *     expression=AssignmentExpression
 */
protected void sequence_JSXSpreadAttribute(ISerializationContext context, JSXSpreadAttribute semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.JSX_SPREAD_ATTRIBUTE__EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.JSX_SPREAD_ATTRIBUTE__EXPRESSION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getJSXSpreadAttributeAccess().getExpressionAssignmentExpressionParserRuleCall_2_0(), semanticObject.getExpression());
    feeder.finish();
}

/**
 * Contexts:
 *     AnnotationArgument returns LiteralAnnotationArgument
 *     LiteralAnnotationArgument returns LiteralAnnotationArgument
 *
 * Constraint:
 *     literal=Literal
 */
protected void sequence_LiteralAnnotationArgument(ISerializationContext context, LiteralAnnotationArgument semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.LITERAL_ANNOTATION_ARGUMENT__LITERAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.LITERAL_ANNOTATION_ARGUMENT__LITERAL));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getLiteralAnnotationArgumentAccess().getLiteralLiteralParserRuleCall_0(), semanticObject.getLiteral());
    feeder.finish();
}

/**
 * Contexts:
 *     Entry returns Entry
 *
 * Constraint:
 *     (key=WORD value=MULTILINE)
 */
protected void sequence_Entry(ISerializationContext context, Entry semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, DslPackage.Literals.ENTRY__KEY) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DslPackage.Literals.ENTRY__KEY));
        if (transientValues.isValueTransient(semanticObject, DslPackage.Literals.ENTRY__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DslPackage.Literals.ENTRY__VALUE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getEntryAccess().getKeyWORDParserRuleCall_1_0(), semanticObject.getKey());
    feeder.accept(grammarAccess.getEntryAccess().getValueMULTILINEParserRuleCall_5_0(), semanticObject.getValue());
    feeder.finish();
}

/**
 * Contexts:
 *     TemplateHead returns TemplateSegment
 *
 * Constraint:
 *     rawValue=TEMPLATE_HEAD
 */
protected void sequence_TemplateHead(ISerializationContext context, TemplateSegment semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTemplateHeadAccess().getRawValueTEMPLATE_HEADTerminalRuleCall_1_0(), semanticObject.getRawValue());
    feeder.finish();
}

/**
 * Contexts:
 *     TemplateMiddle returns TemplateSegment
 *
 * Constraint:
 *     rawValue=TemplateMiddleLiteral
 */
protected void sequence_TemplateMiddle(ISerializationContext context, TemplateSegment semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTemplateMiddleAccess().getRawValueTemplateMiddleLiteralParserRuleCall_1_0(), semanticObject.getRawValue());
    feeder.finish();
}

/**
 * Contexts:
 *     TemplateTail returns TemplateSegment
 *
 * Constraint:
 *     rawValue=TemplateTailLiteral
 */
protected void sequence_TemplateTail(ISerializationContext context, TemplateSegment semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.TEMPLATE_SEGMENT__RAW_VALUE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTemplateTailAccess().getRawValueTemplateTailLiteralParserRuleCall_1_0(), semanticObject.getRawValue());
    feeder.finish();
}

/**
 * Contexts:
 *     AnnotationArgument returns TypeRefAnnotationArgument
 *     TypeRefAnnotationArgument returns TypeRefAnnotationArgument
 *
 * Constraint:
 *     typeRef=TypeRef
 */
protected void sequence_TypeRefAnnotationArgument(ISerializationContext context, TypeRefAnnotationArgument semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.TYPE_REF_ANNOTATION_ARGUMENT__TYPE_REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.TYPE_REF_ANNOTATION_ARGUMENT__TYPE_REF));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTypeRefAnnotationArgumentAccess().getTypeRefTypeRefParserRuleCall_0(), semanticObject.getTypeRef());
    feeder.finish();
}

/**
 * Contexts:
 *     ExecModule returns ExecModule
 *
 * Constraint:
 *     execModule=BootstrapModule
 */
protected void sequence_ExecModule(ISerializationContext context, ExecModule semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4mfPackage.Literals.EXEC_MODULE__EXEC_MODULE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4mfPackage.Literals.EXEC_MODULE__EXEC_MODULE));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getExecModuleAccess().getExecModuleBootstrapModuleParserRuleCall_3_0(), semanticObject.getExecModule());
    feeder.finish();
}

/**
 * Contexts:
 *     ExtendedRuntimeEnvironment returns ExtendedRuntimeEnvironment
 *
 * Constraint:
 *     extendedRuntimeEnvironment=ProjectReference
 */
protected void sequence_ExtendedRuntimeEnvironment(ISerializationContext context, ExtendedRuntimeEnvironment semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4mfPackage.Literals.EXTENDED_RUNTIME_ENVIRONMENT__EXTENDED_RUNTIME_ENVIRONMENT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4mfPackage.Literals.EXTENDED_RUNTIME_ENVIRONMENT__EXTENDED_RUNTIME_ENVIRONMENT));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getExtendedRuntimeEnvironmentAccess().getExtendedRuntimeEnvironmentProjectReferenceParserRuleCall_3_0(), semanticObject.getExtendedRuntimeEnvironment());
    feeder.finish();
}

/**
 * Constraint:
 *     ref=[ReferenceableDefs|QN]
 */
protected void sequence_ValRef(EObject context, ValRef semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.VAL_REF__REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.VAL_REF__REF));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getValRefAccess().getRefReferenceableDefsQNParserRuleCall_0_1(), semanticObject.getRef());
    feeder.finish();
}

/**
 * Contexts:
 *     ProvidedRuntimeLibraryDependency returns ProvidedRuntimeLibraryDependency
 *
 * Constraint:
 *     project=SimpleProjectDescription
 */
protected void sequence_ProvidedRuntimeLibraryDependency(ISerializationContext context, ProvidedRuntimeLibraryDependency semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4mfPackage.Literals.PROJECT_REFERENCE__PROJECT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4mfPackage.Literals.PROJECT_REFERENCE__PROJECT));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getProvidedRuntimeLibraryDependencyAccess().getProjectSimpleProjectDescriptionParserRuleCall_0(), semanticObject.getProject());
    feeder.finish();
}

/**
 * Contexts:
 *     TestedProject returns TestedProject
 *
 * Constraint:
 *     project=SimpleProjectDescription
 */
protected void sequence_TestedProject(ISerializationContext context, TestedProject semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4mfPackage.Literals.PROJECT_REFERENCE__PROJECT) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4mfPackage.Literals.PROJECT_REFERENCE__PROJECT));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getTestedProjectAccess().getProjectSimpleProjectDescriptionParserRuleCall_0(), semanticObject.getProject());
    feeder.finish();
}

/**
 * Constraint:
 *     name=ID
 *
 * Features:
 *    name[1, 1]
 */
protected void sequence_Position_Position(EObject context, Position semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, IOIPackage.Literals.POSITION__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, IOIPackage.Literals.POSITION__NAME));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getPositionAccess().getNameIDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.finish();
}