Examples with NamedValue org.osate.aadl2.NamedValue used on opensource projects

Example 26 with NamedValue

use of org.osate.aadl2.NamedValue in project osate-plugin by sireum.

the class HAMRPropertyProvider method getPlatformsFromElement.

public static List<Platform> getPlatformsFromElement(NamedElement ne) {
    List<Platform> r = new ArrayList<>();
    try {
        Property p = GetProperties.lookupPropertyDefinition(ne, PROP_HAMR__PLATFORM);
        List<? extends PropertyExpression> propertyValues = ne.getPropertyValueList(p);
        for (PropertyExpression pe : propertyValues) {
            String v = ((EnumerationLiteral) ((NamedValue) pe).getNamedValue()).getName();
            r.add(Platform.valueOf(v));
        }
    } catch (PropertyLookupException e) {
    }
    return r;
}

Example 27 with NamedValue

use of org.osate.aadl2.NamedValue in project AMASE by loonwerks.

the class AbstractSafetySemanticSequencer method sequence.

@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
    EPackage epackage = semanticObject.eClass().getEPackage();
    ParserRule rule = context.getParserRule();
    Action action = context.getAssignedAction();
    Set<Parameter> parameters = context.getEnabledBooleanParameters();
    if (epackage == Aadl2Package.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case Aadl2Package.ARRAY_RANGE:
                sequence_ArrayRange(context, (ArrayRange) semanticObject);
                return;
            case Aadl2Package.BASIC_PROPERTY_ASSOCIATION:
                sequence_FieldPropertyAssociation(context, (BasicPropertyAssociation) semanticObject);
                return;
            case Aadl2Package.BOOLEAN_LITERAL:
                sequence_BooleanLiteral(context, (BooleanLiteral) semanticObject);
                return;
            case Aadl2Package.CLASSIFIER_VALUE:
                sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
                return;
            case Aadl2Package.COMPUTED_VALUE:
                sequence_ComputedTerm(context, (ComputedValue) semanticObject);
                return;
            case Aadl2Package.CONTAINED_NAMED_ELEMENT:
                sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
                return;
            case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
                sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
                return;
            case Aadl2Package.INTEGER_LITERAL:
                sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
                return;
            case Aadl2Package.LIST_VALUE:
                sequence_ListTerm(context, (ListValue) semanticObject);
                return;
            case Aadl2Package.MODAL_PROPERTY_VALUE:
                if (rule == grammarAccess.getModalPropertyValueRule()) {
                    sequence_ModalPropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getOptionalModalPropertyValueRule()) {
                    sequence_OptionalModalPropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyValueRule()) {
                    sequence_PropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.NAMED_VALUE:
                if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
                    sequence_ConstantValue(context, (NamedValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
                    sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.OPERATION:
                sequence_SignedConstant(context, (Operation) semanticObject);
                return;
            case Aadl2Package.PROPERTY_ASSOCIATION:
                if (rule == grammarAccess.getBasicPropertyAssociationRule()) {
                    sequence_BasicPropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPModelRule() || rule == grammarAccess.getContainedPropertyAssociationRule()) {
                    sequence_ContainedPropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyAssociationRule()) {
                    sequence_PropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.RANGE_VALUE:
                sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
                return;
            case Aadl2Package.REAL_LITERAL:
                sequence_RealTerm(context, (RealLiteral) semanticObject);
                return;
            case Aadl2Package.RECORD_VALUE:
                if (rule == grammarAccess.getOldRecordTermRule()) {
                    sequence_OldRecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
                    sequence_RecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.REFERENCE_VALUE:
                sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
                return;
            case Aadl2Package.STRING_LITERAL:
                sequence_StringTerm(context, (StringLiteral) semanticObject);
                return;
        }
    else if (epackage == AgreePackage.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case AgreePackage.AGREE_CONTRACT:
                sequence_AgreeContract(context, (AgreeContract) semanticObject);
                return;
            case AgreePackage.AGREE_CONTRACT_LIBRARY:
                sequence_AgreeLibrary(context, (AgreeContractLibrary) semanticObject);
                return;
            case AgreePackage.AGREE_CONTRACT_SUBCLAUSE:
                sequence_AgreeSubclause(context, (AgreeContractSubclause) semanticObject);
                return;
            case AgreePackage.ALWAYS_STATEMENT:
                sequence_PatternStatement(context, (AlwaysStatement) semanticObject);
                return;
            case AgreePackage.ARG:
                sequence_Arg(context, (Arg) semanticObject);
                return;
            case AgreePackage.ARRAY_LITERAL_EXPR:
                sequence_ArrayLiteralExpr(context, (ArrayLiteralExpr) semanticObject);
                return;
            case AgreePackage.ARRAY_SUB_EXPR:
                sequence_ArraySubExpr(context, (ArraySubExpr) semanticObject);
                return;
            case AgreePackage.ARRAY_TYPE:
                sequence_Type(context, (ArrayType) semanticObject);
                return;
            case AgreePackage.ARRAY_UPDATE_EXPR:
                sequence_ArrayUpdateExpr(context, (ArrayUpdateExpr) semanticObject);
                return;
            case AgreePackage.ASSERT_STATEMENT:
                sequence_NamedSpecStatement(context, (AssertStatement) semanticObject);
                return;
            case AgreePackage.ASSIGN_STATEMENT:
                sequence_AssignStatement(context, (AssignStatement) semanticObject);
                return;
            case AgreePackage.ASSUME_STATEMENT:
                sequence_NamedSpecStatement(context, (AssumeStatement) semanticObject);
                return;
            case AgreePackage.ASYNCH_STATEMENT:
                sequence_SynchStatement(context, (AsynchStatement) semanticObject);
                return;
            case AgreePackage.BINARY_EXPR:
                sequence_AddSubExpr_AndExpr_ArrowExpr_EquivExpr_ImpliesExpr_MultDivExpr_OrExpr_PowerExpr_RelateExpr(context, (BinaryExpr) semanticObject);
                return;
            case AgreePackage.BOOL_LIT_EXPR:
                sequence_TermExpr(context, (BoolLitExpr) semanticObject);
                return;
            case AgreePackage.CALEN_STATEMENT:
                sequence_SynchStatement(context, (CalenStatement) semanticObject);
                return;
            case AgreePackage.CALL_EXPR:
                sequence_TermExpr(context, (CallExpr) semanticObject);
                return;
            case AgreePackage.CLOSED_TIME_INTERVAL:
                sequence_TimeInterval(context, (ClosedTimeInterval) semanticObject);
                return;
            case AgreePackage.CONST_STATEMENT:
                sequence_ConstStatement(context, (ConstStatement) semanticObject);
                return;
            case AgreePackage.DOUBLE_DOT_REF:
                sequence_DoubleDotRef(context, (DoubleDotRef) semanticObject);
                return;
            case AgreePackage.ENUM_LIT_EXPR:
                sequence_TermExpr(context, (EnumLitExpr) semanticObject);
                return;
            case AgreePackage.ENUM_STATEMENT:
                sequence_EnumStatement(context, (EnumStatement) semanticObject);
                return;
            case AgreePackage.EQ_STATEMENT:
                sequence_EqStatement(context, (EqStatement) semanticObject);
                return;
            case AgreePackage.EVENT_EXPR:
                sequence_TermExpr(context, (EventExpr) semanticObject);
                return;
            case AgreePackage.EXISTS_EXPR:
                sequence_ExistsExpr(context, (ExistsExpr) semanticObject);
                return;
            case AgreePackage.FLATMAP_EXPR:
                sequence_FlatmapExpr(context, (FlatmapExpr) semanticObject);
                return;
            case AgreePackage.FLOOR_CAST:
                sequence_TermExpr(context, (FloorCast) semanticObject);
                return;
            case AgreePackage.FN_DEF:
                sequence_FnDef(context, (FnDef) semanticObject);
                return;
            case AgreePackage.FOLD_LEFT_EXPR:
                sequence_FoldLeftExpr(context, (FoldLeftExpr) semanticObject);
                return;
            case AgreePackage.FOLD_RIGHT_EXPR:
                sequence_FoldRightExpr(context, (FoldRightExpr) semanticObject);
                return;
            case AgreePackage.FORALL_EXPR:
                sequence_ForallExpr(context, (ForallExpr) semanticObject);
                return;
            case AgreePackage.GET_PROPERTY_EXPR:
                sequence_PreDefFnExpr(context, (GetPropertyExpr) semanticObject);
                return;
            case AgreePackage.GUARANTEE_STATEMENT:
                sequence_NamedSpecStatement(context, (GuaranteeStatement) semanticObject);
                return;
            case AgreePackage.IF_THEN_ELSE_EXPR:
                sequence_IfThenElseExpr(context, (IfThenElseExpr) semanticObject);
                return;
            case AgreePackage.INDICES_EXPR:
                sequence_TermExpr(context, (IndicesExpr) semanticObject);
                return;
            case AgreePackage.INPUT_STATEMENT:
                sequence_InputStatement(context, (InputStatement) semanticObject);
                return;
            case AgreePackage.INT_LIT_EXPR:
                sequence_TermExpr(context, (IntLitExpr) semanticObject);
                return;
            case AgreePackage.LATCHED_EXPR:
                sequence_TermExpr(context, (LatchedExpr) semanticObject);
                return;
            case AgreePackage.LATCHED_STATEMENT:
                sequence_SynchStatement(context, (LatchedStatement) semanticObject);
                return;
            case AgreePackage.LEMMA_STATEMENT:
                sequence_NamedSpecStatement(context, (LemmaStatement) semanticObject);
                return;
            case AgreePackage.LIBRARY_FN_DEF:
                sequence_LibraryFnDef(context, (LibraryFnDef) semanticObject);
                return;
            case AgreePackage.LINEARIZATION_DEF:
                sequence_LinearizationDef(context, (LinearizationDef) semanticObject);
                return;
            case AgreePackage.LINEARIZATION_INTERVAL:
                sequence_LinearizationInterval(context, (LinearizationInterval) semanticObject);
                return;
            case AgreePackage.MN_SYNCH_STATEMENT:
                sequence_SynchStatement(context, (MNSynchStatement) semanticObject);
                return;
            case AgreePackage.NAMED_ELM_EXPR:
                sequence_TermExpr(context, (NamedElmExpr) semanticObject);
                return;
            case AgreePackage.NAMED_ID:
                sequence_NamedID(context, (NamedID) semanticObject);
                return;
            case AgreePackage.NODE_BODY_EXPR:
                sequence_NodeBodyExpr(context, (NodeBodyExpr) semanticObject);
                return;
            case AgreePackage.NODE_DEF:
                sequence_NodeDef(context, (NodeDef) semanticObject);
                return;
            case AgreePackage.NODE_EQ:
                sequence_NodeStmt(context, (NodeEq) semanticObject);
                return;
            case AgreePackage.NODE_LEMMA:
                sequence_NodeStmt(context, (NodeLemma) semanticObject);
                return;
            case AgreePackage.OPEN_LEFT_TIME_INTERVAL:
                sequence_TimeInterval(context, (OpenLeftTimeInterval) semanticObject);
                return;
            case AgreePackage.OPEN_RIGHT_TIME_INTERVAL:
                sequence_TimeInterval(context, (OpenRightTimeInterval) semanticObject);
                return;
            case AgreePackage.OPEN_TIME_INTERVAL:
                sequence_TimeInterval(context, (OpenTimeInterval) semanticObject);
                return;
            case AgreePackage.ORDER_STATEMENT:
                sequence_OrderStatement(context, (OrderStatement) semanticObject);
                return;
            case AgreePackage.PERIODIC_STATEMENT:
                sequence_RealTimeStatement(context, (PeriodicStatement) semanticObject);
                return;
            case AgreePackage.PRE_EXPR:
                sequence_TermExpr(context, (PreExpr) semanticObject);
                return;
            case AgreePackage.PREV_EXPR:
                sequence_PreDefFnExpr(context, (PrevExpr) semanticObject);
                return;
            case AgreePackage.PRIM_TYPE:
                sequence_BaseType(context, (PrimType) semanticObject);
                return;
            case AgreePackage.PROPERTY_STATEMENT:
                sequence_PropertyStatement(context, (PropertyStatement) semanticObject);
                return;
            case AgreePackage.REACHABLE_STATEMENT:
                sequence_NamedSpecStatement(context, (ReachableStatement) semanticObject);
                return;
            case AgreePackage.REAL_CAST:
                sequence_TermExpr(context, (RealCast) semanticObject);
                return;
            case AgreePackage.REAL_LIT_EXPR:
                sequence_TermExpr(context, (RealLitExpr) semanticObject);
                return;
            case AgreePackage.RECORD_DEF:
                sequence_RecordDef(context, (RecordDef) semanticObject);
                return;
            case AgreePackage.RECORD_LIT_EXPR:
                sequence_TermExpr(context, (RecordLitExpr) semanticObject);
                return;
            case AgreePackage.RECORD_UPDATE_EXPR:
                sequence_RecordUpdateExpr(context, (RecordUpdateExpr) semanticObject);
                return;
            case AgreePackage.SELECTION_EXPR:
                sequence_SelectionExpr(context, (SelectionExpr) semanticObject);
                return;
            case AgreePackage.SPORADIC_STATEMENT:
                sequence_RealTimeStatement(context, (SporadicStatement) semanticObject);
                return;
            case AgreePackage.SYNCH_STATEMENT:
                sequence_SynchStatement(context, (SynchStatement) semanticObject);
                return;
            case AgreePackage.TAG_EXPR:
                sequence_TagExpr(context, (TagExpr) semanticObject);
                return;
            case AgreePackage.THIS_REF:
                sequence_ComponentRef(context, (ThisRef) semanticObject);
                return;
            case AgreePackage.TIME_EXPR:
                sequence_TermExpr(context, (TimeExpr) semanticObject);
                return;
            case AgreePackage.TIME_FALL_EXPR:
                sequence_TermExpr(context, (TimeFallExpr) semanticObject);
                return;
            case AgreePackage.TIME_OF_EXPR:
                sequence_TermExpr(context, (TimeOfExpr) semanticObject);
                return;
            case AgreePackage.TIME_RISE_EXPR:
                sequence_TermExpr(context, (TimeRiseExpr) semanticObject);
                return;
            case AgreePackage.UNARY_EXPR:
                sequence_UnaryExpr(context, (UnaryExpr) semanticObject);
                return;
            case AgreePackage.UNINTERPRETED_FN_DEF:
                sequence_UninterpretedFnDef(context, (UninterpretedFnDef) semanticObject);
                return;
            case AgreePackage.WHEN_HOLDS_STATEMENT:
                sequence_WhenStatement(context, (WhenHoldsStatement) semanticObject);
                return;
            case AgreePackage.WHEN_OCCURS_STATMENT:
                sequence_WhenStatement(context, (WhenOccursStatment) semanticObject);
                return;
            case AgreePackage.WHENEVER_BECOMES_TRUE_STATEMENT:
                sequence_WheneverStatement(context, (WheneverBecomesTrueStatement) semanticObject);
                return;
            case AgreePackage.WHENEVER_HOLDS_STATEMENT:
                sequence_WheneverStatement(context, (WheneverHoldsStatement) semanticObject);
                return;
            case AgreePackage.WHENEVER_IMPLIES_STATEMENT:
                sequence_WheneverStatement(context, (WheneverImpliesStatement) semanticObject);
                return;
            case AgreePackage.WHENEVER_OCCURS_STATEMENT:
                sequence_WheneverStatement(context, (WheneverOccursStatement) semanticObject);
                return;
        }
    else if (epackage == SafetyPackage.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case SafetyPackage.ACTIVATION_STATEMENT:
                sequence_SpecStatement(context, (ActivationStatement) semanticObject);
                return;
            case SafetyPackage.ANALYSIS_STATEMENT:
                sequence_SpecStatement(context, (AnalysisStatement) semanticObject);
                return;
            case SafetyPackage.CLOSED_SAFETY_INTERVAL:
                sequence_SafetyInterval(context, (ClosedSafetyInterval) semanticObject);
                return;
            case SafetyPackage.DISABLE_STATEMENT:
                sequence_FaultSubcomponent(context, (DisableStatement) semanticObject);
                return;
            case SafetyPackage.DURATION_STATEMENT:
                if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
                    sequence_FaultSubcomponent(context, (DurationStatement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
                    sequence_HWFaultSubcomponent(context, (DurationStatement) semanticObject);
                    return;
                } else
                    break;
            case SafetyPackage.ENABLER_CONDITION:
                sequence_TriggerCondition(context, (EnablerCondition) semanticObject);
                return;
            case SafetyPackage.EQ_VALUE:
                sequence_SafetyEqStatement(context, (EqValue) semanticObject);
                return;
            case SafetyPackage.FAULT_COUNT_BEHAVIOR:
                sequence_AnalysisBehavior(context, (FaultCountBehavior) semanticObject);
                return;
            case SafetyPackage.FAULT_STATEMENT:
                sequence_SpecStatement(context, (FaultStatement) semanticObject);
                return;
            case SafetyPackage.HW_FAULT_STATEMENT:
                sequence_SpecStatement(context, (HWFaultStatement) semanticObject);
                return;
            case SafetyPackage.INPUT_STATEMENT:
                sequence_FaultSubcomponent(context, (edu.umn.cs.crisys.safety.safety.InputStatement) semanticObject);
                return;
            case SafetyPackage.INTERVAL_EQ:
                sequence_SafetyEqStatement(context, (IntervalEq) semanticObject);
                return;
            case SafetyPackage.OPEN_LEFT_SAFETY_INTERVAL:
                sequence_SafetyInterval(context, (OpenLeftSafetyInterval) semanticObject);
                return;
            case SafetyPackage.OPEN_RIGHT_SAFETY_INTERVAL:
                sequence_SafetyInterval(context, (OpenRightSafetyInterval) semanticObject);
                return;
            case SafetyPackage.OPEN_SAFETY_INTERVAL:
                sequence_SafetyInterval(context, (OpenSafetyInterval) semanticObject);
                return;
            case SafetyPackage.OUTPUT_STATEMENT:
                sequence_FaultSubcomponent(context, (OutputStatement) semanticObject);
                return;
            case SafetyPackage.PERMANENT_CONSTRAINT:
                sequence_TemporalConstraint(context, (PermanentConstraint) semanticObject);
                return;
            case SafetyPackage.PROBABILITY_BEHAVIOR:
                sequence_AnalysisBehavior(context, (ProbabilityBehavior) semanticObject);
                return;
            case SafetyPackage.PROBABILITY_STATEMENT:
                if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
                    sequence_FaultSubcomponent(context, (ProbabilityStatement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
                    sequence_HWFaultSubcomponent(context, (ProbabilityStatement) semanticObject);
                    return;
                } else
                    break;
            case SafetyPackage.PROPAGATE_STATEMENT:
                sequence_SpecStatement(context, (PropagateStatement) semanticObject);
                return;
            case SafetyPackage.PROPAGATION_TYPE_STATEMENT:
                if (rule == grammarAccess.getElementSafetyRule() || rule == grammarAccess.getFaultSubcomponentRule()) {
                    sequence_FaultSubcomponent(context, (PropagationTypeStatement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getHWFaultSubcomponentRule()) {
                    sequence_HWFaultSubcomponent(context, (PropagationTypeStatement) semanticObject);
                    return;
                } else
                    break;
            case SafetyPackage.RANGE_EQ:
                sequence_SafetyEqStatement(context, (RangeEq) semanticObject);
                return;
            case SafetyPackage.SAFETY_CONTRACT:
                sequence_SafetyContract(context, (SafetyContract) semanticObject);
                return;
            case SafetyPackage.SAFETY_CONTRACT_LIBRARY:
                sequence_SafetyLibrary(context, (SafetyContractLibrary) semanticObject);
                return;
            case SafetyPackage.SAFETY_CONTRACT_SUBCLAUSE:
                sequence_SafetySubclause(context, (SafetyContractSubclause) semanticObject);
                return;
            case SafetyPackage.SET_EQ:
                sequence_SafetyEqStatement(context, (SetEq) semanticObject);
                return;
            case SafetyPackage.TRANSIENT_CONSTRAINT:
                sequence_TemporalConstraint(context, (TransientConstraint) semanticObject);
                return;
            case SafetyPackage.TRIGGER_STATEMENT:
                sequence_FaultSubcomponent(context, (TriggerStatement) semanticObject);
                return;
            case SafetyPackage.ASYMMETRIC:
                sequence_PropagationTypeConstraint(context, (asymmetric) semanticObject);
                return;
            case SafetyPackage.SYMMETRIC:
                sequence_PropagationTypeConstraint(context, (symmetric) semanticObject);
                return;
        }
    if (errorAcceptor != null)
        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}

Example 28 with NamedValue

use of org.osate.aadl2.NamedValue in project VERDICT by ge-high-assurance.

the class Aadl2Vdm method getStrRepofExpr.

/**
 * @author Paul Meng
 * The calling function should know the size of the return array
 */
String[] getStrRepofExpr(PropertyExpression expr) {
    String[] values = new String[4];
    if (expr instanceof BooleanLiteralImpl) {
        BooleanLiteralImpl bool = ((BooleanLiteralImpl) expr);
        // values[0] = bool.getValue()?"1":"0";
        values[0] = bool.getValue() ? "true" : "false";
    } else if (expr instanceof IntegerLiteralImpl) {
        IntegerLiteralImpl intVal = ((IntegerLiteralImpl) expr);
        values[0] = String.valueOf((int) intVal.getValue());
    } else if (expr instanceof NamedValueImpl) {
        NamedValueImpl namedValue = ((NamedValueImpl) expr);
        if (namedValue.getNamedValue() instanceof EnumerationLiteralImpl) {
            EnumerationLiteralImpl enu = ((EnumerationLiteralImpl) namedValue.getNamedValue());
            values[0] = enu.getName();
        } else {
            throw new RuntimeException("Unsupported property value: " + namedValue.getNamedValue());
        }
    } else if (expr instanceof ListValueImpl) {
        ListValueImpl listValue = (ListValueImpl) expr;
        if (listValue.getOwnedListElements().size() == 1) {
            values = getStrRepofExpr(listValue.getOwnedListElements().get(0));
        } else {
            throw new RuntimeException("Unexpected!");
        }
    } else if (expr instanceof ReferenceValueImpl) {
        // We only consider the value of expr is a bus expression here.
        ReferenceValueImpl refValue = (ReferenceValueImpl) expr;
        if (refValue.getContainmentPathElements().size() == 1) {
            ContainmentPathElement element = refValue.getContainmentPathElements().get(0);
            NamedElement namedElement = element.getNamedElement();
            if (namedElement instanceof BusSubcomponent) {
                ComponentImplementation impl = ((BusSubcomponent) namedElement).getContainingComponentImpl();
                String compTypeName = impl.getTypeName();
                values[0] = compTypeName;
                values[1] = impl.getName();
                values[2] = "";
                values[3] = namedElement.getName();
            } else {
                throw new RuntimeException("Unexpected!");
            }
        } else if (refValue.getContainmentPathElements().size() == 2) {
            // This is to deal with the expression "subcomponent . bus"
            ContainmentPathElement elementZero = refValue.getContainmentPathElements().get(0);
            ContainmentPathElement elementOne = refValue.getContainmentPathElements().get(1);
            NamedElement namedElementZero = elementZero.getNamedElement();
            NamedElement namedElementOne = elementOne.getNamedElement();
            if (namedElementZero instanceof SystemSubcomponent) {
                ComponentImplementation impl = ((SystemSubcomponent) namedElementZero).getComponentImplementation();
                values[0] = impl.getTypeName();
                values[1] = impl.getName();
                values[2] = namedElementZero.getName();
                values[3] = namedElementOne.getName();
            } else {
                throw new RuntimeException("Unexpected!");
            }
        } else {
            throw new RuntimeException("Unexpected number of property values: " + refValue.getContainmentPathElements().size());
        }
    } else if (expr instanceof StringLiteralImpl) {
        StringLiteralImpl strVal = ((StringLiteralImpl) expr);
        values[0] = strVal.getValue();
    } else {
        throw new RuntimeException("Unsupported property value: " + expr);
    }
    return values;
}

Example 29 with NamedValue

use of org.osate.aadl2.NamedValue in project VERDICT by ge-high-assurance.

the class Aadl2CsvTranslator method getStrRepofExpr.

/**
 * The calling function should know the size of the return array
 */
String[] getStrRepofExpr(PropertyExpression expr) {
    String[] values = new String[4];
    if (expr instanceof BooleanLiteralImpl) {
        BooleanLiteralImpl bool = ((BooleanLiteralImpl) expr);
        values[0] = bool.getValue() ? "1" : "0";
    } else if (expr instanceof IntegerLiteralImpl) {
        IntegerLiteralImpl intVal = ((IntegerLiteralImpl) expr);
        values[0] = String.valueOf((int) intVal.getValue());
    } else if (expr instanceof NamedValueImpl) {
        NamedValueImpl namedValue = ((NamedValueImpl) expr);
        if (namedValue.getNamedValue() instanceof EnumerationLiteralImpl) {
            EnumerationLiteralImpl enu = ((EnumerationLiteralImpl) namedValue.getNamedValue());
            values[0] = enu.getName();
        } else {
            throw new RuntimeException("Unsupported property value: " + namedValue.getNamedValue());
        }
    } else if (expr instanceof ListValueImpl) {
        ListValueImpl listValue = (ListValueImpl) expr;
        if (listValue.getOwnedListElements().size() == 1) {
            values = getStrRepofExpr(listValue.getOwnedListElements().get(0));
        } else {
            throw new RuntimeException("Unexpected!");
        }
    } else if (expr instanceof ReferenceValueImpl) {
        // We only consider the value of expr is a bus expression here.
        ReferenceValueImpl refValue = (ReferenceValueImpl) expr;
        if (refValue.getContainmentPathElements().size() == 1) {
            ContainmentPathElement element = refValue.getContainmentPathElements().get(0);
            NamedElement namedElement = element.getNamedElement();
            if (namedElement instanceof BusSubcomponent) {
                ComponentImplementation impl = ((BusSubcomponent) namedElement).getContainingComponentImpl();
                String compTypeName = impl.getTypeName();
                values[0] = compTypeName;
                values[1] = impl.getName();
                values[2] = "";
                values[3] = namedElement.getName();
            } else {
                throw new RuntimeException("Unexpected!");
            }
        } else if (refValue.getContainmentPathElements().size() == 2) {
            // This is to deal with the expression "subcomponent . bus"
            ContainmentPathElement elementZero = refValue.getContainmentPathElements().get(0);
            ContainmentPathElement elementOne = refValue.getContainmentPathElements().get(1);
            NamedElement namedElementZero = elementZero.getNamedElement();
            NamedElement namedElementOne = elementOne.getNamedElement();
            if (namedElementZero instanceof SystemSubcomponent) {
                ComponentImplementation impl = ((SystemSubcomponent) namedElementZero).getComponentImplementation();
                values[0] = impl.getTypeName();
                values[1] = impl.getName();
                values[2] = namedElementZero.getName();
                values[3] = namedElementOne.getName();
            } else {
                throw new RuntimeException("Unexpected!");
            }
        } else {
            throw new RuntimeException("Unexpected number of property values: " + refValue.getContainmentPathElements().size());
        }
    } else if (expr instanceof StringLiteralImpl) {
        StringLiteralImpl strVal = ((StringLiteralImpl) expr);
        values[0] = strVal.getValue();
    } else {
        throw new RuntimeException("Unsupported property value: " + expr);
    }
    return values;
}

Example 30 with NamedValue

use of org.osate.aadl2.NamedValue in project osate2 by osate.

the class AadlBaUnparser method unparse.

// This is very specific to AADL BA. It cannot be used elsewhere.
private static String unparse(PropertyExpression pe) {
    int type = pe.eClass().getClassifierID();
    String result = "";
    switch(type) {
        case Aadl2Package.STRING_LITERAL:
            {
                // TODO: Should quotes be added there?
                result = ((StringLiteral) pe).getValue();
                break;
            }
        case Aadl2Package.LIST_VALUE:
        case Aadl2Package.REAL_LITERAL:
        case Aadl2Package.BOOLEAN_LITERAL:
        case Aadl2Package.NUMBER_VALUE:
        case Aadl2Package.INTEGER_LITERAL:
        case Aadl2Package.RECORD_VALUE:
        case Aadl2Package.RANGE_VALUE:
            {
                BasicProperty container = PropertyUtils.getContainingProperty(pe);
                result = container.getName();
                break;
            }
        case Aadl2Package.NAMED_VALUE:
            {
                NamedValue nv = (NamedValue) pe;
                AbstractNamedValue anv = nv.getNamedValue();
                if (anv instanceof PropertyExpression) {
                    result = unparse((PropertyExpression) anv);
                } else if (anv instanceof EnumerationLiteral) {
                    BasicProperty container = PropertyUtils.getContainingProperty(pe);
                    result = container.getName();
                    break;
                } else {
                    String msg = anv.getClass().getSimpleName() + " is not supported (in NamedValue)";
                    System.err.println(msg);
                    throw new UnsupportedOperationException(msg);
                }
                break;
            }
        default:
            {
                String msg = "unparsing " + pe.getClass().getSimpleName() + " is not supported yet";
                System.err.println(msg);
                throw new UnsupportedOperationException(msg);
            }
    }
    return result;
}