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

Example 16 with AbstractNamedValue

use of org.osate.aadl2.AbstractNamedValue in project AGREE by loonwerks.

the class AgreeTypeSystem method hasFloatDataRepresentation.

public static boolean hasFloatDataRepresentation(Classifier classifier) {
    boolean result = false;
    EList<PropertyAssociation> propertyAssociations = classifier.getAllPropertyAssociations();
    for (PropertyAssociation propertyAssociation : propertyAssociations) {
        Property property = propertyAssociation.getProperty();
        try {
            PropertyExpression propertyExpr = classifier.getSimplePropertyValue(property);
            if ("Data_Model::Data_Representation".equals(property.getQualifiedName()) && propertyExpr instanceof NamedValue) {
                AbstractNamedValue abstractNamedValue = ((NamedValue) propertyExpr).getNamedValue();
                if (abstractNamedValue instanceof EnumerationLiteral && "Float".equals(((EnumerationLiteral) abstractNamedValue).getName())) {
                    result = true;
                }
            }
        } catch (Exception e) {
            continue;
        }
    }
    return result;
}

Example 17 with AbstractNamedValue

use of org.osate.aadl2.AbstractNamedValue in project AGREE by loonwerks.

the class AgreeTypeSystem method typeDefFromClassifier.

public static TypeDef typeDefFromClassifier(Classifier c) {
    if (c instanceof DataType || (c instanceof DataImplementation && ((DataImplementation) c).getAllSubcomponents().isEmpty() && ((DataImplementation) c).getType() != null)) {
        // Includes special case for data implementations implementing extensions of primitive types
        Classifier classifierType = c instanceof DataImplementation ? ((DataImplementation) c).getType() : c;
        List<PropertyAssociation> pas = classifierType.getAllPropertyAssociations();
        for (Classifier classType : classifierType.getSelfPlusAllExtended()) {
            if (classType != null && hasIntegerDataRepresentation(classType)) {
                for (PropertyAssociation choice : pas) {
                    Property p = choice.getProperty();
                    PropertyExpression v = choice.getOwnedValues().get(0).getOwnedValue();
                    String key = p.getQualifiedName();
                    if (key.equals("Data_Model::Integer_Range")) {
                        if (v instanceof RangeValue) {
                            try {
                                RangeValue rangeValue = (RangeValue) v;
                                long min = intFromPropExp(rangeValue.getMinimum()).get();
                                long max = intFromPropExp(rangeValue.getMaximum()).get();
                                return new RangeIntTypeDef(min, max);
                            } catch (Exception e) {
                                return Prim.ErrorTypeDef;
                            }
                        }
                    }
                }
                return Prim.IntTypeDef;
            } else if (classType != null && hasFloatDataRepresentation(classType)) {
                for (PropertyAssociation choice : pas) {
                    Property p = choice.getProperty();
                    PropertyExpression v = choice.getOwnedValues().get(0).getOwnedValue();
                    String key = p.getQualifiedName();
                    if (key.equals("Data_Model::Real_Range")) {
                        if (v instanceof RangeValue) {
                            try {
                                RangeValue rangeValue = (RangeValue) v;
                                double min = realFromPropExp(rangeValue.getMinimum()).get();
                                double max = realFromPropExp(rangeValue.getMaximum()).get();
                                return new RangeRealTypeDef(min, max);
                            } catch (Exception e) {
                                return Prim.ErrorTypeDef;
                            }
                        }
                    }
                }
                return Prim.RealTypeDef;
            } else if (classType != null && hasBooleanDataRepresentation(classType)) {
                return Prim.BoolTypeDef;
            }
        }
        boolean prop_isArray = false;
        int prop_arraySize = 0;
        TypeDef prop_arrayBaseType = null;
        boolean prop_isEnum = false;
        List<String> prop_enumValues = null;
        for (PropertyAssociation choice : pas) {
            Property p = choice.getProperty();
            PropertyExpression v = choice.getOwnedValues().get(0).getOwnedValue();
            String key = p.getQualifiedName();
            key = key == null ? p.getName() : key;
            if (key == null) {
                return Prim.ErrorTypeDef;
            }
            if (key.equalsIgnoreCase("Data_Model::Data_Representation")) {
                if (v instanceof NamedValue) {
                    AbstractNamedValue anv = ((NamedValue) v).getNamedValue();
                    if (anv instanceof EnumerationLiteral) {
                        EnumerationLiteral el = (EnumerationLiteral) anv;
                        prop_isArray = el.getName().equals("Array");
                        prop_isEnum = el.getName().equals("Enum");
                    }
                }
            } else if (key.equalsIgnoreCase("Data_Model::Enumerators")) {
                if (v instanceof ListValue) {
                    EList<PropertyExpression> peList = ((ListValue) v).getOwnedListElements();
                    String prefix = c.getQualifiedName() + "_";
                    prop_enumValues = new ArrayList<>();
                    for (PropertyExpression pe : peList) {
                        if (pe instanceof StringLiteral) {
                            String enumString = prefix + ((StringLiteral) pe).getValue();
                            prop_enumValues.add(enumString);
                        }
                    }
                }
            } else if (key.equalsIgnoreCase("Data_Model::Base_Type")) {
                if (v instanceof ListValue) {
                    ListValue l = (ListValue) v;
                    PropertyExpression pe = l.getOwnedListElements().get(0);
                    if (pe instanceof ClassifierValue) {
                        prop_arrayBaseType = typeDefFromClassifier(((ClassifierValue) pe).getClassifier());
                    }
                }
            } else if (key.equalsIgnoreCase("Data_Model::Dimension")) {
                if (v instanceof ListValue) {
                    ListValue l = (ListValue) v;
                    PropertyExpression pe = l.getOwnedListElements().get(0);
                    prop_arraySize = Math.toIntExact(intFromPropExp(pe).orElse((long) -1).longValue());
                }
            }
        }
        if (prop_isArray && prop_arraySize > 0 && prop_arrayBaseType != null) {
            return new ArrayTypeDef(prop_arrayBaseType, prop_arraySize, Optional.of(c));
        } else if (prop_isEnum && prop_enumValues != null) {
            String name = c.getQualifiedName();
            return new EnumTypeDef(name, prop_enumValues, c);
        }
    } else if (c instanceof ComponentClassifier) {
        Map<String, TypeDef> fields = new HashMap<>();
        Classifier currClsfr = c;
        while (currClsfr != null) {
            ComponentType ct = null;
            if (currClsfr instanceof ComponentImplementation) {
                EList<Subcomponent> subcomps = ((ComponentImplementation) currClsfr).getAllSubcomponents();
                for (Subcomponent sub : subcomps) {
                    String fieldName = sub.getName();
                    if (sub.getClassifier() != null) {
                        boolean prop_isArray = false;
                        int prop_arraySize = 0;
                        boolean prop_isEnum = false;
                        List<String> prop_enumValues = null;
                        for (PropertyAssociation pa : sub.getOwnedPropertyAssociations()) {
                            Property p = pa.getProperty();
                            String key = p.getQualifiedName();
                            key = key == null ? p.getName() : key;
                            PropertyExpression v = null;
                            if (!pa.getOwnedValues().isEmpty()) {
                                v = pa.getOwnedValues().get(0).getOwnedValue();
                            } else {
                                continue;
                            }
                            if (key.equals("Data_Model::Data_Representation")) {
                                if (v instanceof NamedValue) {
                                    AbstractNamedValue anv = ((NamedValue) v).getNamedValue();
                                    if (anv instanceof EnumerationLiteral) {
                                        EnumerationLiteral el = (EnumerationLiteral) anv;
                                        prop_isArray = el.getName().equals("Array");
                                        prop_isEnum = el.getName().equals("Enum");
                                    }
                                }
                            } else if (key.equals("Data_Model::Dimension")) {
                                if (v instanceof ListValue) {
                                    ListValue l = (ListValue) v;
                                    PropertyExpression pe = l.getOwnedListElements().get(0);
                                    prop_arraySize = Math.toIntExact(intFromPropExp(pe).orElse((long) -1).longValue());
                                }
                            } else if (key.equals("Data_Model::Enumerators")) {
                                if (v instanceof ListValue) {
                                    EList<PropertyExpression> peList = ((ListValue) v).getOwnedListElements();
                                    String prefix = c.getQualifiedName() + "_";
                                    prop_enumValues = new ArrayList<>();
                                    for (PropertyExpression pe : peList) {
                                        if (pe instanceof StringLiteral) {
                                            String enumString = prefix + ((StringLiteral) pe).getValue();
                                            prop_enumValues.add(enumString);
                                        }
                                    }
                                }
                            }
                        }
                        if (prop_isArray && prop_arraySize > 0) {
                            TypeDef typeDef = new ArrayTypeDef(typeDefFromClassifier(sub.getClassifier()), prop_arraySize, Optional.empty());
                            fields.putIfAbsent(fieldName, typeDef);
                        } else if (prop_isEnum && prop_enumValues != null) {
                            String name = c.getQualifiedName();
                            TypeDef typeDef = new EnumTypeDef(name, prop_enumValues, c);
                            fields.putIfAbsent(fieldName, typeDef);
                        } else if (sub.getArrayDimensions().size() == 0) {
                            TypeDef typeDef = typeDefFromClassifier(sub.getClassifier());
                            fields.putIfAbsent(fieldName, typeDef);
                        } else if (sub.getArrayDimensions().size() == 1) {
                            ArrayDimension ad = sub.getArrayDimensions().get(0);
                            int size = Math.toIntExact(getArraySize(ad));
                            TypeDef stem = typeDefFromClassifier(sub.getClassifier());
                            TypeDef typeDef = new ArrayTypeDef(stem, size, Optional.empty());
                            fields.putIfAbsent(fieldName, typeDef);
                        }
                    }
                }
                ct = ((ComponentImplementation) currClsfr).getType();
            } else if (c instanceof ComponentType) {
                ct = (ComponentType) currClsfr;
            }
            if (ct != null) {
                EList<Feature> features = ct.getAllFeatures();
                for (Feature feature : features) {
                    String fieldName = feature.getName();
                    if (feature.getClassifier() != null) {
                        if (feature.getArrayDimensions().size() == 0) {
                            TypeDef typeDef = typeDefFromClassifier(feature.getClassifier());
                            fields.putIfAbsent(fieldName, typeDef);
                        } else if (feature.getArrayDimensions().size() == 1) {
                            ArrayDimension ad = feature.getArrayDimensions().get(0);
                            int size = Math.toIntExact(getArraySize(ad));
                            TypeDef stem = typeDefFromClassifier(feature.getClassifier());
                            TypeDef typeDef = new ArrayTypeDef(stem, size, Optional.empty());
                            fields.putIfAbsent(fieldName, typeDef);
                        }
                    }
                }
                for (AnnexSubclause annex : AnnexUtil.getAllAnnexSubclauses(currClsfr, AgreePackage.eINSTANCE.getAgreeContractSubclause())) {
                    AgreeContract contract = (AgreeContract) ((AgreeContractSubclause) annex).getContract();
                    for (SpecStatement spec : contract.getSpecs()) {
                        List<Arg> args = new ArrayList<>();
                        if (spec instanceof EqStatement) {
                            args = ((EqStatement) spec).getLhs();
                        } else if (spec instanceof InputStatement) {
                            args = ((InputStatement) spec).getLhs();
                        }
                        for (Arg arg : args) {
                            String fieldName = arg.getName();
                            TypeDef typeDef = typeDefFromNE(arg);
                            fields.putIfAbsent(fieldName, typeDef);
                        }
                        if (spec instanceof ConstStatement) {
                            String fieldName = ((ConstStatement) spec).getName();
                            TypeDef typeDef = AgreeTypeSystem.typeDefFromType(((ConstStatement) spec).getType());
                            fields.putIfAbsent(fieldName, typeDef);
                        }
                    }
                }
            }
            currClsfr = currClsfr.getExtended();
        }
        String name = c.getQualifiedName();
        return new RecordTypeDef(name, fields, c);
    }
    return Prim.ErrorTypeDef;
}

Example 18 with AbstractNamedValue

use of org.osate.aadl2.AbstractNamedValue in project AGREE by loonwerks.

the class AgreeTypeSystem method hasIntegerDataRepresentation.

public static boolean hasIntegerDataRepresentation(Classifier classifier) {
    boolean result = false;
    EList<PropertyAssociation> propertyAssociations = classifier.getAllPropertyAssociations();
    for (PropertyAssociation propertyAssociation : propertyAssociations) {
        Property property = propertyAssociation.getProperty();
        try {
            PropertyExpression propertyExpr = classifier.getSimplePropertyValue(property);
            if ("Data_Model::Data_Representation".equals(property.getQualifiedName()) && propertyExpr instanceof NamedValue) {
                AbstractNamedValue abstractNamedValue = ((NamedValue) propertyExpr).getNamedValue();
                if (abstractNamedValue instanceof EnumerationLiteral && "Integer".equals(((EnumerationLiteral) abstractNamedValue).getName())) {
                    result = true;
                }
            }
        } catch (Exception e) {
            continue;
        }
    }
    return result;
}

Example 19 with AbstractNamedValue

use of org.osate.aadl2.AbstractNamedValue in project AGREE by loonwerks.

the class AgreeTypeSystem method getTypeDefFromFeatureOrSubcomp.

private static TypeDef getTypeDefFromFeatureOrSubcomp(NamedElement ne) {
    Classifier cl = null;
    if (ne instanceof Feature) {
        cl = ((Feature) ne).getClassifier();
    } else if (ne instanceof Subcomponent) {
        cl = ((Subcomponent) ne).getClassifier();
    }
    List<ArrayDimension> dims = null;
    if (ne instanceof ArrayableElement) {
        dims = ((ArrayableElement) ne).getArrayDimensions();
    }
    if (cl == null) {
        return Prim.ErrorTypeDef;
    }
    TypeDef clsTypeDef = typeDefFromClassifier(cl);
    if (dims == null || dims.size() == 0) {
        boolean prop_isArray = false;
        int prop_arraySize = 0;
        List<PropertyAssociation> pas = null;
        if (ne instanceof Feature) {
            pas = ((Feature) ne).getOwnedPropertyAssociations();
        } else if (ne instanceof Subcomponent) {
            pas = ((Subcomponent) ne).getOwnedPropertyAssociations();
        }
        if (pas != null) {
            for (PropertyAssociation pchoice : pas) {
                Property p = pchoice.getProperty();
                PropertyExpression v = pchoice.getOwnedValues().get(0).getOwnedValue();
                String key = p.getQualifiedName();
                if (key.equals("Data_Model::Data_Representation")) {
                    if (v instanceof NamedValue) {
                        AbstractNamedValue anv = ((NamedValue) v).getNamedValue();
                        if (anv instanceof EnumerationLiteral) {
                            EnumerationLiteral el = (EnumerationLiteral) anv;
                            prop_isArray = el.getName().equals("Array");
                        }
                    }
                } else if (key.equals("Data_Model::Dimension")) {
                    if (v instanceof ListValue) {
                        ListValue l = (ListValue) v;
                        PropertyExpression pe = l.getOwnedListElements().get(0);
                        prop_arraySize = Math.toIntExact(intFromPropExp(pe).orElse((long) -1).longValue());
                    }
                }
            }
        }
        if (prop_isArray && prop_arraySize > 0) {
            return new ArrayTypeDef(clsTypeDef, prop_arraySize, Optional.empty());
        } else if (prop_isArray && prop_arraySize <= 0) {
            return Prim.ErrorTypeDef;
        } else {
            return clsTypeDef;
        }
    } else if (dims.size() == 1) {
        long size = getArraySize(dims.get(0));
        return new ArrayTypeDef(clsTypeDef, Math.toIntExact(size), Optional.empty());
    }
    return Prim.ErrorTypeDef;
}

Example 20 with AbstractNamedValue

use of org.osate.aadl2.AbstractNamedValue in project AGREE by loonwerks.

the class AgreeTypeSystem method inferPropExp.

private static TypeDef inferPropExp(PropertyExpression pe) {
    if (pe instanceof IntegerLiteral) {
        return Prim.IntTypeDef;
    } else if (pe instanceof RealLiteral) {
        return Prim.RealTypeDef;
    } else if (pe instanceof NamedValue) {
        NamedValue nv = (NamedValue) pe;
        AbstractNamedValue anv = nv.getNamedValue();
        if (anv instanceof PropertyConstant) {
            return inferPropExp(((PropertyConstant) anv).getConstantValue());
        }
    }
    return Prim.ErrorTypeDef;
}