1. 包列表
  2. 类列表
  3. org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider

Java 类org.eclipse.xtext.serializer.sequencer.ISemanticNodeProvider.INodesForEObjectProvider 实例源码

项目：jason-eclipse-plugin    文件：AbstractAslSemanticSequencer.java    
/**
 * Constraint:
 *     (tk_for=TK_FOR log_expr=Log_expr plan_term=Plan_term)
 */
protected void sequence_StmtFOR(EObject context, StmtFOR semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_FOR__TK_FOR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_FOR__TK_FOR));
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_FOR__LOG_EXPR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_FOR__LOG_EXPR));
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_FOR__PLAN_TERM) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_FOR__PLAN_TERM));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getStmtFORAccess().getTk_forTK_FORParserRuleCall_0_0(), semanticObject.getTk_for());
    feeder.accept(grammarAccess.getStmtFORAccess().getLog_exprLog_exprParserRuleCall_2_0(), semanticObject.getLog_expr());
    feeder.accept(grammarAccess.getStmtFORAccess().getPlan_termPlan_termParserRuleCall_4_0(), semanticObject.getPlan_term());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractAslSemanticSequencer.java    
/**
 * Constraint:
 *     (tk_while=TK_WHILE log_expr=Log_expr plan_term=Plan_term)
 */
protected void sequence_StmtWHILE(EObject context, StmtWHILE semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_WHILE__TK_WHILE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_WHILE__TK_WHILE));
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_WHILE__LOG_EXPR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_WHILE__LOG_EXPR));
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STMT_WHILE__PLAN_TERM) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STMT_WHILE__PLAN_TERM));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getStmtWHILEAccess().getTk_whileTK_WHILEParserRuleCall_0_0(), semanticObject.getTk_while());
    feeder.accept(grammarAccess.getStmtWHILEAccess().getLog_exprLog_exprParserRuleCall_2_0(), semanticObject.getLog_expr());
    feeder.accept(grammarAccess.getStmtWHILEAccess().getPlan_termPlan_termParserRuleCall_4_0(), semanticObject.getPlan_term());
    feeder.finish();
}
项目：xtext-extras    文件：XbaseSemanticSequencer.java    
protected boolean isXShortClosure(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
    if (values.isEmpty() || values.size() > 2 || !(values.get(0) instanceof XClosure))
        return false;
    XClosure closure = (XClosure) values.get(0);
    if (!closure.isExplicitSyntax())
        return false;
    INode node = nodes.getNodeForMultiValue(reference, 0, 0, closure);
    if (node != null) {
        if (node.getGrammarElement() instanceof RuleCall)
            return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXShortClosureRule();
        if (node.getGrammarElement() instanceof Action)
            return node.getGrammarElement() == grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0();
        return false;
    }
    return true;
}
项目：xtext-extras    文件：XbaseSemanticSequencer.java    
protected boolean isBuilderSyntax(List<?> values, EReference reference, INodesForEObjectProvider nodes) {
    if (values.isEmpty())
        return false;
    int lastIndex = values.size() - 1;
    Object lastValue = values.get(lastIndex);
    if (!(lastValue instanceof XClosure))
        return false;
    INode node = nodes.getNodeForMultiValue(reference, lastIndex, lastIndex, values.get(lastIndex));
    if (node != null) {
        if (node.getGrammarElement() instanceof RuleCall)
            return ((RuleCall) node.getGrammarElement()).getRule() == grammarAccess.getXClosureRule();
        if (node.getGrammarElement() instanceof Action) 
            return node.getGrammarElement() == grammarAccess.getXClosureAccess().getXClosureAction_0_0_0();
        return false;
    }
    return true;
}
项目：dsl-devkit    文件：AbstractFormatterTestLanguageSemanticSequencer.java    
/**
 * Constraint:
 *     (val1=Datatype1 val2=Datatype2 val3=Datatype3)
 */
protected void sequence_Datatypes(EObject context, Datatypes semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL1) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL1));
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL2) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL2));
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL3) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.DATATYPES__VAL3));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getDatatypesAccess().getVal1Datatype1ParserRuleCall_1_0(), semanticObject.getVal1());
    feeder.accept(grammarAccess.getDatatypesAccess().getVal2Datatype2ParserRuleCall_3_0(), semanticObject.getVal2());
    feeder.accept(grammarAccess.getDatatypesAccess().getVal3Datatype3ParserRuleCall_4_0(), semanticObject.getVal3());
    feeder.finish();
}
项目：dsl-devkit    文件：AbstractFormatterTestLanguageSemanticSequencer.java    
/**
 * Constraint:
 *     (value=ID first=ID second=ID)
 */
protected void sequence_TestOffset(EObject context, TestOffset semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__VALUE));
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__FIRST) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__FIRST));
        if(transientValues.isValueTransient(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__SECOND) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FormatterTestLanguagePackage.Literals.TEST_OFFSET__SECOND));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getTestOffsetAccess().getValueIDTerminalRuleCall_3_0(), semanticObject.getValue());
    feeder.accept(grammarAccess.getTestOffsetAccess().getFirstIDTerminalRuleCall_5_0(), semanticObject.getFirst());
    feeder.accept(grammarAccess.getTestOffsetAccess().getSecondIDTerminalRuleCall_6_0(), semanticObject.getSecond());
    feeder.finish();
}
项目：dsl-devkit    文件：AbstractCheckSemanticSequencer.java    
/**
 * Constraint:
 *     (declaredParam=JvmFormalParameter forExpression=XExpression eachExpression=XExpression)
 */
protected void sequence_XForLoopExpression(EObject context, XForLoopExpression semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__FOR_EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__FOR_EXPRESSION));
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__EACH_EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__EACH_EXPRESSION));
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__DECLARED_PARAM) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__DECLARED_PARAM));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0(), semanticObject.getDeclaredParam());
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0(), semanticObject.getForExpression());
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0(), semanticObject.getEachExpression());
    feeder.finish();
}
项目：dsl-devkit    文件：AbstractCheckCfgSemanticSequencer.java    
/**
 * Constraint:
 *     (declaredParam=JvmFormalParameter forExpression=XExpression eachExpression=XExpression)
 */
protected void sequence_XForLoopExpression(EObject context, XForLoopExpression semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__FOR_EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__FOR_EXPRESSION));
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__EACH_EXPRESSION) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__EACH_EXPRESSION));
        if(transientValues.isValueTransient(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__DECLARED_PARAM) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, XbasePackage.Literals.XFOR_LOOP_EXPRESSION__DECLARED_PARAM));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0(), semanticObject.getDeclaredParam());
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0(), semanticObject.getForExpression());
    feeder.accept(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0(), semanticObject.getEachExpression());
    feeder.finish();
}
项目：DocIT    文件：AbstractIOISemanticSequencer.java    
/**
 * 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();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     value=BOOLEAN
 */
protected void sequence_BooleanLiteral(EObject context, BooleanLiteral semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.BOOLEAN_LITERAL__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.BOOLEAN_LITERAL__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getBooleanLiteralAccess().getValueBOOLEANParserRuleCall_0(), semanticObject.isValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     value=DOUBLE
 */
protected void sequence_DoubleLiteral(EObject context, DoubleLiteral semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.DOUBLE_LITERAL__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.DOUBLE_LITERAL__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getDoubleLiteralAccess().getValueDOUBLEParserRuleCall_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     ref=[HashtagDef|QN]
 */
protected void sequence_ExportHashtag(EObject context, ExportHashtag semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.EXPORT_HASHTAG__REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.EXPORT_HASHTAG__REF));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getExportHashtagAccess().getRefHashtagDefQNParserRuleCall_1_0_1(), semanticObject.getRef());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     ref=[NamedRuntimeDef|QN]
 */
protected void sequence_ExportRuntimeName(EObject context, ExportRuntimeName semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.EXPORT_RUNTIME_NAME__REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.EXPORT_RUNTIME_NAME__REF));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getExportRuntimeNameAccess().getRefNamedRuntimeDefQNParserRuleCall_0_1(), semanticObject.getRef());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     module=ModuleDef
 */
protected void sequence_ImportDef(EObject context, ImportDef semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.IMPORT_DEF__MODULE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.IMPORT_DEF__MODULE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getImportDefAccess().getModuleModuleDefParserRuleCall_1_0(), semanticObject.getModule());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     value=INT
 */
protected void sequence_IntegerLiteral(EObject context, IntegerLiteral semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.INTEGER_LITERAL__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.INTEGER_LITERAL__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getIntegerLiteralAccess().getValueINTTerminalRuleCall_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     (name=ID value=ValueOperation)
 */
protected void sequence_KeywordParameterValue(EObject context, KeywordParameterValue semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.PARAMETER_VALUE__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.PARAMETER_VALUE__VALUE));
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.KEYWORD_PARAMETER_VALUE__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.KEYWORD_PARAMETER_VALUE__NAME));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getKeywordParameterValueAccess().getNameIDParserRuleCall_0_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getKeywordParameterValueAccess().getValueValueOperationParserRuleCall_2_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     module=ModuleParts
 */
protected void sequence_PackageDef(EObject context, PackageDef semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.PACKAGE_DEF__MODULE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.PACKAGE_DEF__MODULE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getPackageDefAccess().getModuleModulePartsParserRuleCall_1_0(), semanticObject.getModule());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     value=ValueOperation
 */
protected void sequence_PositionParameterValue(EObject context, PositionParameterValue semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.PARAMETER_VALUE__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.PARAMETER_VALUE__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getPositionParameterValueAccess().getValueValueOperationParserRuleCall_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     (type=STRING codeStr=SCALA_CODE_BLOCK)
 */
protected void sequence_ScalaCodeBlock(EObject context, ScalaCodeBlock semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.CODE_BLOCK__TYPE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.CODE_BLOCK__TYPE));
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.SCALA_CODE_BLOCK__CODE_STR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.SCALA_CODE_BLOCK__CODE_STR));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getScalaCodeBlockAccess().getTypeSTRINGTerminalRuleCall_2_0(), semanticObject.getType());
    feeder.accept(grammarAccess.getScalaCodeBlockAccess().getCodeStrSCALA_CODE_BLOCKParserRuleCall_4_0(), semanticObject.getCodeStr());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     (name=ID value=STRING)
 */
protected void sequence_SimpleParameterValue(EObject context, SimpleParameterValue semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.SIMPLE_PARAMETER_VALUE__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.SIMPLE_PARAMETER_VALUE__NAME));
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.SIMPLE_PARAMETER_VALUE__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.SIMPLE_PARAMETER_VALUE__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getSimpleParameterValueAccess().getNameIDParserRuleCall_0_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getSimpleParameterValueAccess().getValueSTRINGTerminalRuleCall_2_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     value=STRING
 */
protected void sequence_StringLiteral(EObject context, StringLiteral semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.STRING_LITERAL__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.STRING_LITERAL__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     name=TypeNameStr
 */
protected void sequence_TypeName(EObject context, TypeName semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.TYPE_NAME__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.TYPE_NAME__NAME));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getTypeNameAccess().getNameTypeNameStrParserRuleCall_0(), semanticObject.getName());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     typeRef=[TypeDef|QN]
 */
protected void sequence_TypeRef(EObject context, TypeRef semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.TYPE_REF__TYPE_REF) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.TYPE_REF__TYPE_REF));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getTypeRefAccess().getTypeRefTypeDefQNParserRuleCall_1_0_1(), semanticObject.getTypeRef());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     (op=UNARY_OPS expr=UnaryOrPrimary)
 */
protected void sequence_UnaryOperation(EObject context, UnaryOperation semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.UNARY_OPERATION__OP) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.UNARY_OPERATION__OP));
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.UNARY_OPERATION__EXPR) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.UNARY_OPERATION__EXPR));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getUnaryOperationAccess().getOpUNARY_OPSParserRuleCall_1_0(), semanticObject.getOp());
    feeder.accept(grammarAccess.getUnaryOperationAccess().getExprUnaryOrPrimaryParserRuleCall_2_0(), semanticObject.getExpr());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * Constraint:
 *     (name=CAPITALIZED_ID value=ValueOperation)
 */
protected void sequence_ValDef(EObject context, ValDef semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.NAMED_ABSTRACT_DEF__NAME) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.NAMED_ABSTRACT_DEF__NAME));
        if(transientValues.isValueTransient(semanticObject, KronusPackage.Literals.VAL_DEF__VALUE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, KronusPackage.Literals.VAL_DEF__VALUE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getValDefAccess().getNameCAPITALIZED_IDTerminalRuleCall_1_0(), semanticObject.getName());
    feeder.accept(grammarAccess.getValDefAccess().getValueValueOperationParserRuleCall_3_0(), semanticObject.getValue());
    feeder.finish();
}
项目：Saturn    文件：KronusSemanticSequencer.java    
/**
 * 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();
}
项目：SurveyDSL    文件：AbstractQueryITSemanticSequencer.java    
/**
 * Constraint:
 *     title=EString
 */
protected void sequence_MultiTextItem(EObject context, MultiTextItem semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, QueryITPackage.Literals.MULTI_TEXT_ITEM__TITLE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, QueryITPackage.Literals.MULTI_TEXT_ITEM__TITLE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getMultiTextItemAccess().getTitleEStringParserRuleCall_1_0(), semanticObject.getTitle());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractAslSemanticSequencer.java    
/**
 * Constraint:
 *     literal=Literal
 */
protected void sequence_Function(EObject context, Function semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.FUNCTION__LITERAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.FUNCTION__LITERAL));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getFunctionAccess().getLiteralLiteralParserRuleCall_0(), semanticObject.getLiteral());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractAslSemanticSequencer.java    
/**
 * Constraint:
 *     literal=Literal
 */
protected void sequence_Initial_goal(EObject context, Initial_goal semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.INITIAL_GOAL__LITERAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.INITIAL_GOAL__LITERAL));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getInitial_goalAccess().getLiteralLiteralParserRuleCall_1_0(), semanticObject.getLiteral());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractAslSemanticSequencer.java    
/**
 * Constraint:
 *     string=STRINGT
 */
protected void sequence_String(EObject context, jasonide.xtext.asl.asl.String semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, AslPackage.Literals.STRING__STRING) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, AslPackage.Literals.STRING__STRING));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getStringAccess().getStringSTRINGTTerminalRuleCall_0(), semanticObject.getString());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     agentArchClass=ClsDef
 *
 * Features:
 *    agentArchClass[1, 1]
 */
protected void sequence_AgentArchClass(EObject context, AgentArchClass semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.AGENT_ARCH_CLASS__AGENT_ARCH_CLASS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.AGENT_ARCH_CLASS__AGENT_ARCH_CLASS));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getAgentArchClassAccess().getAgentArchClassClsDefParserRuleCall_1_0(), semanticObject.getAgentArchClass());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     agentClass=ClsDef
 *
 * Features:
 *    agentClass[1, 1]
 */
protected void sequence_AgentClass(EObject context, AgentClass semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.AGENT_CLASS__AGENT_CLASS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.AGENT_CLASS__AGENT_CLASS));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getAgentClassAccess().getAgentClassClsDefParserRuleCall_1_0(), semanticObject.getAgentClass());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     beliefBaseClass=ClsDef
 *
 * Features:
 *    beliefBaseClass[1, 1]
 */
protected void sequence_BeliefBaseClass(EObject context, BeliefBaseClass semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.BELIEF_BASE_CLASS__BELIEF_BASE_CLASS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.BELIEF_BASE_CLASS__BELIEF_BASE_CLASS));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getBeliefBaseClassAccess().getBeliefBaseClassClsDefParserRuleCall_1_0(), semanticObject.getBeliefBaseClass());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     nomeclasspath=STRING
 *
 * Features:
 *    nomeclasspath[1, 1]
 */
protected void sequence_Classpath(EObject context, Classpath semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.CLASSPATH__NOMECLASSPATH) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.CLASSPATH__NOMECLASSPATH));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getClasspathAccess().getNomeclasspathSTRINGTerminalRuleCall_0_0(), semanticObject.getNomeclasspath());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     (directive=ID_WITH_STARTING_LCLETTER clsDirective=ClsDef)
 *
 * Features:
 *    directive[1, 1]
 *    clsDirective[1, 1]
 */
protected void sequence_Directive(EObject context, Directive semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.DIRECTIVE__DIRECTIVE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.DIRECTIVE__DIRECTIVE));
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.DIRECTIVE__CLS_DIRECTIVE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.DIRECTIVE__CLS_DIRECTIVE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getDirectiveAccess().getDirectiveID_WITH_STARTING_LCLETTERTerminalRuleCall_0_0(), semanticObject.getDirective());
    feeder.accept(grammarAccess.getDirectiveAccess().getClsDirectiveClsDefParserRuleCall_2_0(), semanticObject.getClsDirective());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     environmentLocus=STRING
 *
 * Features:
 *    environmentLocus[1, 1]
 */
protected void sequence_EnvironmentLocus(EObject context, EnvironmentLocus semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.ENVIRONMENT_LOCUS__ENVIRONMENT_LOCUS) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.ENVIRONMENT_LOCUS__ENVIRONMENT_LOCUS));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getEnvironmentLocusAccess().getEnvironmentLocusSTRINGTerminalRuleCall_1_0(), semanticObject.getEnvironmentLocus());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     infrastructure=ClsDef
 *
 * Features:
 *    infrastructure[1, 1]
 */
protected void sequence_Infrastructure(EObject context, Infrastructure semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.INFRASTRUCTURE__INFRASTRUCTURE) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.INFRASTRUCTURE__INFRASTRUCTURE));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getInfrastructureAccess().getInfrastructureClsDefParserRuleCall_2_0(), semanticObject.getInfrastructure());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     instances=INT_LITERAL
 *
 * Features:
 *    instances[1, 1]
 */
protected void sequence_Instances(EObject context, Instances semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.INSTANCES__INSTANCES) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.INSTANCES__INSTANCES));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getInstancesAccess().getInstancesINT_LITERALTerminalRuleCall_1_0(), semanticObject.getInstances());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     val=INT_LITERAL
 *
 * Features:
 *    val[1, 1]
 */
protected void sequence_Nrcbp(EObject context, Nrcbp semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.NRCBP__VAL) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.NRCBP__VAL));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getNrcbpAccess().getValINT_LITERALTerminalRuleCall_2_0(), semanticObject.getVal());
    feeder.finish();
}
项目：jason-eclipse-plugin    文件：AbstractMas2jSemanticSequencer.java    
/**
 * Constraint:
 *     nomesourcepath=STRING
 *
 * Features:
 *    nomesourcepath[1, 1]
 */
protected void sequence_Sourcepath(EObject context, Sourcepath semanticObject) {
    if(errorAcceptor != null) {
        if(transientValues.isValueTransient(semanticObject, Mas2jPackage.Literals.SOURCEPATH__NOMESOURCEPATH) == ValueTransient.YES)
            errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, Mas2jPackage.Literals.SOURCEPATH__NOMESOURCEPATH));
    }
    INodesForEObjectProvider nodes = createNodeProvider(semanticObject);
    SequenceFeeder feeder = createSequencerFeeder(semanticObject, nodes);
    feeder.accept(grammarAccess.getSourcepathAccess().getNomesourcepathSTRINGTerminalRuleCall_0_0(), semanticObject.getNomesourcepath());
    feeder.finish();
}