Java 类org.eclipse.xtext.serializer.acceptor.SequenceFeeder 实例源码

/**
 * 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 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:
 *     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:
 *     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:
 *     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 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:
 *     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:
 *     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:
 *     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:
 *     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:
 *     Type returns VoidType
 *     VoidType returns VoidType
 *
 * Constraint:
 *     name='void'
 */
protected void sequence_VoidType(ISerializationContext context, VoidType 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.getVoidTypeAccess().getNameVoidKeyword_1_0(), semanticObject.getName());
    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:
 *     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:
 *     ExportedVariableDeclarationOrBinding<Yield> returns ExportedVariableBinding
 *     ExportedVariableDeclarationOrBinding returns ExportedVariableBinding
 *     ExportedVariableBinding<Yield> returns ExportedVariableBinding
 *     ExportedVariableBinding returns ExportedVariableBinding
 *
 * Constraint:
 *     (pattern=BindingPattern expression=AssignmentExpression)
 */
protected void sequence_ExportedVariableBinding(ISerializationContext context, ExportedVariableBinding semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.VARIABLE_BINDING__PATTERN) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.VARIABLE_BINDING__PATTERN));
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.VARIABLE_BINDING__EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.VARIABLE_BINDING__EXPRESSION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getExportedVariableBindingAccess().getPatternBindingPatternParserRuleCall_0_0(), semanticObject.getPattern());
    feeder.accept(grammarAccess.getExportedVariableBindingAccess().getExpressionAssignmentExpressionParserRuleCall_2_0(), semanticObject.getExpression());
    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:
 *     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:
 *     LetIdentifierRef returns IdentifierRef
 *
 * Constraint:
 *     id=[IdentifiableElement|LetAsIdentifier]
 */
protected void sequence_LetIdentifierRef(ISerializationContext context, IdentifierRef semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, N4JSPackage.Literals.IDENTIFIER_REF__ID) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, N4JSPackage.Literals.IDENTIFIER_REF__ID));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getLetIdentifierRefAccess().getIdIdentifiableElementLetAsIdentifierParserRuleCall_0_1(), semanticObject.eGet(N4JSPackage.Literals.IDENTIFIER_REF__ID, false));
    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:
 *     NoSubstitutionTemplate returns TemplateSegment
 *
 * Constraint:
 *     rawValue=NO_SUBSTITUTION_TEMPLATE_LITERAL
 */
protected void sequence_NoSubstitutionTemplate(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.getNoSubstitutionTemplateAccess().getRawValueNO_SUBSTITUTION_TEMPLATE_LITERALTerminalRuleCall_1_0(), semanticObject.getRawValue());
    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();
}

/**
 * Contexts:
 *     ProjectReference returns ProjectReference
 *
 * Constraint:
 *     project=SimpleProjectDescription
 */
protected void sequence_ProjectReference(ISerializationContext context, ProjectReference 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.getProjectReferenceAccess().getProjectSimpleProjectDescriptionParserRuleCall_0(), semanticObject.getProject());
    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();
}

/**
 * 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();
}

/**
 * Contexts:
 *     Description returns Description
 *
 * Constraint:
 *     name=STRING
 */
protected void sequence_Description(ISerializationContext context, Description semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, MyDslPackage.Literals.DESCRIPTION__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, MyDslPackage.Literals.DESCRIPTION__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getDescriptionAccess().getNameSTRINGTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     ExposedParameter returns ExposedParameter
 *
 * Constraint:
 *     name=ID
 */
protected void sequence_ExposedParameter(ISerializationContext context, ExposedParameter semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, BromiumPackage.Literals.EXPOSED_PARAMETER__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BromiumPackage.Literals.EXPOSED_PARAMETER__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getExposedParameterAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     Postcondition returns Postcondition
 *
 * Constraint:
 *     action=WebDriverActionCondition
 */
protected void sequence_Postcondition(ISerializationContext context, Postcondition semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, BromiumPackage.Literals.POSTCONDITION__ACTION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, BromiumPackage.Literals.POSTCONDITION__ACTION));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getPostconditionAccess().getActionWebDriverActionConditionParserRuleCall_3_0(), semanticObject.getAction());
    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:
 *     Severity returns Severity
 *
 * Constraint:
 *     level=SEV
 */
protected void sequence_Severity(ISerializationContext context, Severity semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, DSLPoliciesPackage.Literals.SEVERITY__LEVEL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, DSLPoliciesPackage.Literals.SEVERITY__LEVEL));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getSeverityAccess().getLevelSEVTerminalRuleCall_0(), semanticObject.getLevel());
    feeder.finish();
}

/**
 * Contexts:
 *     Path returns AnyPath
 *     AnyPath returns AnyPath
 *
 * Constraint:
 *     name=StringWithVariables
 */
protected void sequence_AnyPath(ISerializationContext context, AnyPath semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, LcDslPackage.Literals.PATH__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LcDslPackage.Literals.PATH__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getAnyPathAccess().getNameStringWithVariablesParserRuleCall_0(), semanticObject.getName());
    feeder.finish();
}

/**
 * Contexts:
 *     ApplicationExtPoint returns ApplicationExtPoint
 *
 * Constraint:
 *     name=FQName
 */
protected void sequence_ApplicationExtPoint(ISerializationContext context, ApplicationExtPoint semanticObject) {
    if (errorAcceptor != null) {
        if (transientValues.isValueTransient(semanticObject, LcDslPackage.Literals.APPLICATION_EXT_POINT__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, LcDslPackage.Literals.APPLICATION_EXT_POINT__NAME));
    }
    SequenceFeeder feeder = createSequencerFeeder(context, semanticObject);
    feeder.accept(grammarAccess.getApplicationExtPointAccess().getNameFQNameParserRuleCall_1_0(), semanticObject.getName());
    feeder.finish();
}