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

Example 26 with ClassifierValue

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

the class AadlBaParserVisitor method clonePropertyExpression.

private PropertyExpression clonePropertyExpression(PropertyExpression sourcePropertyExpression) {
    PropertyExpression targetPropertyExpression = null;
    if (sourcePropertyExpression instanceof ListValue) {
        ListValue sourceLV = (ListValue) sourcePropertyExpression;
        ListValue targetLV = _coreFact.createListValue();
        for (PropertyExpression propInList : sourceLV.getOwnedListElements()) {
            targetLV.getOwnedListElements().add(clonePropertyExpression(propInList));
        }
        targetPropertyExpression = targetLV;
    } else if (sourcePropertyExpression instanceof StringLiteral) {
        StringLiteral sourceSL = (StringLiteral) sourcePropertyExpression;
        StringLiteral targetSL = _coreFact.createStringLiteral();
        targetSL.setValue(sourceSL.getValue());
        targetPropertyExpression = targetSL;
    } else if (sourcePropertyExpression instanceof IntegerLiteral) {
        IntegerLiteral sourceIL = (IntegerLiteral) sourcePropertyExpression;
        IntegerLiteral targetIL = _coreFact.createIntegerLiteral();
        targetIL.setValue(sourceIL.getValue());
        targetIL.setUnit(sourceIL.getUnit());
        targetPropertyExpression = targetIL;
    } else if (sourcePropertyExpression instanceof RealLiteral) {
        RealLiteral sourceRL = (RealLiteral) sourcePropertyExpression;
        RealLiteral targetRL = _coreFact.createRealLiteral();
        targetRL.setValue(sourceRL.getValue());
        targetRL.setUnit(sourceRL.getUnit());
        targetPropertyExpression = targetRL;
    } else if (sourcePropertyExpression instanceof RecordValue) {
        RecordValue sourceRV = (RecordValue) sourcePropertyExpression;
        RecordValue targetRV = _coreFact.createRecordValue();
        targetRV.getOwnedFieldValues().addAll(sourceRV.getOwnedFieldValues());
        targetPropertyExpression = targetRV;
    } else if (sourcePropertyExpression instanceof BooleanLiteral) {
        BooleanLiteral sourceBL = (BooleanLiteral) sourcePropertyExpression;
        BooleanLiteral targetBL = _coreFact.createBooleanLiteral();
        targetBL.setValue(sourceBL.getValue());
        targetPropertyExpression = targetBL;
    } else if (sourcePropertyExpression instanceof RangeValue) {
        RangeValue sourceRV = (RangeValue) sourcePropertyExpression;
        RangeValue targetRV = _coreFact.createRangeValue();
        targetRV.setMinimum(clonePropertyExpression(sourceRV.getMinimum()));
        targetRV.setMaximum(clonePropertyExpression(sourceRV.getMaximum()));
        targetPropertyExpression = targetRV;
    } else if (sourcePropertyExpression instanceof DeclarativeReferenceValue) {
        DeclarativeReferenceValue sourceDRV = (DeclarativeReferenceValue) sourcePropertyExpression;
        ReferenceValue targetRV = _coreFact.createReferenceValue();
        targetRV.setPath(sourceDRV.getRef());
        targetPropertyExpression = targetRV;
    } else if (sourcePropertyExpression instanceof DeclarativeClassifierValue) {
        DeclarativeClassifierValue sourceDCV = (DeclarativeClassifierValue) sourcePropertyExpression;
        ClassifierValue targetCV = _coreFact.createClassifierValue();
        targetCV.setClassifier(sourceDCV.getClassifier());
        targetPropertyExpression = targetCV;
    }
    return targetPropertyExpression;
}

Example 27 with ClassifierValue

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

the class AadlBaUtils method getFeatureType.

/**
 * Analyze the given AADL Osate element and return its enumeration type.
 *
 * It's an improved version of Osate2 org.osate.parser.AadlSemanticCheckSwitch#getFeatureType
 *
 * @param el the given AADL Osate element
 * @return the given AADL Osate element's type
 * @exception UnsupportedOperationException for the unsupported types
 */
/*
	 * <copyright>
	 * Copyright 2009 by Carnegie Mellon University, all rights reserved.
	 *
	 * Use of the Open Source AADL Tool Environment (OSATE) is subject to the terms of the license set forth
	 * at http://www.eclipse.org/legal/cpl-v10.html.
	 *
	 * NO WARRANTY
	 *
	 * ANY INFORMATION, MATERIALS, SERVICES, INTELLECTUAL PROPERTY OR OTHER PROPERTY OR RIGHTS GRANTED OR PROVIDED BY
	 * CARNEGIE MELLON UNIVERSITY PURSUANT TO THIS LICENSE (HEREINAFTER THE "DELIVERABLES") ARE ON AN "AS-IS" BASIS.
	 * CARNEGIE MELLON UNIVERSITY MAKES NO WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED AS TO ANY MATTER INCLUDING,
	 * BUT NOT LIMITED TO, WARRANTY OF FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, INFORMATIONAL CONTENT,
	 * NONINFRINGEMENT, OR ERROR-FREE OPERATION. CARNEGIE MELLON UNIVERSITY SHALL NOT BE LIABLE FOR INDIRECT, SPECIAL OR
	 * CONSEQUENTIAL DAMAGES, SUCH AS LOSS OF PROFITS OR INABILITY TO USE SAID INTELLECTUAL PROPERTY, UNDER THIS LICENSE,
	 * REGARDLESS OF WHETHER SUCH PARTY WAS AWARE OF THE POSSIBILITY OF SUCH DAMAGES. LICENSEE AGREES THAT IT WILL NOT
	 * MAKE ANY WARRANTY ON BEHALF OF CARNEGIE MELLON UNIVERSITY, EXPRESS OR IMPLIED, TO ANY PERSON CONCERNING THE
	 * APPLICATION OF OR THE RESULTS TO BE OBTAINED WITH THE DELIVERABLES UNDER THIS LICENSE.
	 *
	 * Licensee hereby agrees to defend, indemnify, and hold harmless Carnegie Mellon University, its trustees, officers,
	 * employees, and agents from all claims or demands made against them (and any related losses, expenses, or
	 * attorney's fees) arising out of, or relating to Licensee's and/or its sub licensees' negligent use or willful
	 * misuse of or negligent conduct or willful misconduct regarding the Software, facilities, or other rights or
	 * assistance granted by Carnegie Mellon University under this License, including, but not limited to, any claims of
	 * product liability, personal injury, death, damage to property, or violation of any laws or regulations.
	 *
	 * Carnegie Mellon University Software Engineering Institute authored documents are sponsored by the U.S. Department
	 * of Defense under Contract F19628-00-C-0003. Carnegie Mellon University retains copyrights in all material produced
	 * under this contract. The U.S. Government retains a non-exclusive, royalty-free license to publish or reproduce these
	 * documents, or allow others to do so, for U.S. Government purposes only pursuant to the copyright license
	 * under the contract clause at 252.227.7013.
	 * </copyright>
	 */
public static org.osate.ba.aadlba.FeatureType getFeatureType(Element el) {
    if (el instanceof DataPort) {
        switch(((DataPort) el).getDirection()) {
            case IN:
                return FeatureType.IN_DATA_PORT;
            case OUT:
                return FeatureType.OUT_DATA_PORT;
            case IN_OUT:
                return FeatureType.IN_OUT_DATA_PORT;
        }
    } else if (el instanceof EventPort) {
        switch(((EventPort) el).getDirection()) {
            case IN:
                return FeatureType.IN_EVENT_PORT;
            case OUT:
                return FeatureType.OUT_EVENT_PORT;
            case IN_OUT:
                return FeatureType.IN_OUT_EVENT_PORT;
        }
    } else if (el instanceof EventDataPort) {
        switch(((EventDataPort) el).getDirection()) {
            case IN:
                return FeatureType.IN_EVENT_DATA_PORT;
            case OUT:
                return FeatureType.OUT_EVENT_DATA_PORT;
            case IN_OUT:
                return FeatureType.IN_OUT_EVENT_DATA_PORT;
        }
    } else if (el instanceof FeatureGroup) {
        return FeatureType.FEATURE_GROUP;
    } else if (el instanceof DataAccess) {
        switch(((DataAccess) el).getKind()) {
            case PROVIDES:
                return FeatureType.PROVIDES_DATA_ACCESS;
            case REQUIRES:
                return FeatureType.REQUIRES_DATA_ACCESS;
        }
    } else if (el instanceof SubprogramAccess) {
        switch(((SubprogramAccess) el).getKind()) {
            case PROVIDES:
                return FeatureType.PROVIDES_SUBPROGRAM_ACCESS;
            case REQUIRES:
                return FeatureType.REQUIRES_SUBPROGRAM_ACCESS;
        }
    } else if (el instanceof SubprogramGroupAccess) {
        switch(((SubprogramGroupAccess) el).getKind()) {
            case PROVIDES:
                return FeatureType.PROVIDES_SUBPROGRAM_GROUP_ACCESS;
            case REQUIRES:
                return FeatureType.REQUIRES_SUBPROGRAM_GROUP_ACCESS;
        }
    } else if (el instanceof BusAccess) {
        switch(((BusAccess) el).getKind()) {
            case PROVIDES:
                return FeatureType.PROVIDES_BUS_ACCESS;
            case REQUIRES:
                return FeatureType.REQUIRES_BUS_ACCESS;
        }
    } else if (el instanceof AbstractFeature) {
        return FeatureType.ABSTRACT_FEATURE;
    } else if (el instanceof Parameter) {
        switch(((Parameter) el).getDirection()) {
            case IN:
                return FeatureType.IN_PARAMETER;
            case OUT:
                return FeatureType.OUT_PARAMETER;
            case IN_OUT:
                return FeatureType.IN_OUT_PARAMETER;
        }
    } else if (el instanceof Prototype) {
        if (el instanceof ComponentPrototype) {
            switch(el.eClass().getClassifierID()) {
                case Aadl2Package.SUBPROGRAM_PROTOTYPE:
                    return FeatureType.SUBPROGRAM_PROTOTYPE;
                case Aadl2Package.SUBPROGRAM_GROUP_PROTOTYPE:
                    return FeatureType.SUBPROGRAM_GROUP_PROTOTYPE;
                case Aadl2Package.THREAD_PROTOTYPE:
                    return FeatureType.THREAD_PROTOTYPE;
                case Aadl2Package.THREAD_GROUP_PROTOTYPE:
                    return FeatureType.THREAD_GROUP_PROTOTYPE;
                default:
                    return FeatureType.COMPONENT_PROTOTYPE;
            }
        } else if (el instanceof FeaturePrototype) {
            return getFeaturePrototypeType((FeaturePrototype) el);
        } else if (el instanceof FeatureGroupPrototype) {
            return FeatureType.FEATURE_GROUP_PROTOTYPE;
        }
    } else if (el instanceof PrototypeBinding) {
        if (el instanceof ComponentPrototypeBinding) {
            return FeatureType.COMPONENT_PROTOTYPE_BINDING;
        } else if (el instanceof FeatureGroupPrototypeBinding) {
            return FeatureType.FEATURE_GROUP_PROTOTYPE_BINDING;
        } else // FeaturePrototypeBinding case.
        {
            return FeatureType.FEATURE_PROTOTYPE_BINDING;
        }
    } else if (el instanceof org.osate.aadl2.PropertyConstant) {
        return FeatureType.PROPERTY_CONSTANT;
    } else if (el instanceof org.osate.aadl2.Property) {
        return FeatureType.PROPERTY_VALUE;
    } else if (el instanceof ClassifierValue) {
        return FeatureType.CLASSIFIER_VALUE;
    } else if (el instanceof SubprogramGroup) {
        return FeatureType.SUBPROGRAM_GROUP;
    } else if (el instanceof SubprogramGroupAccess) {
        switch(((SubprogramGroupAccess) el).getKind()) {
            case PROVIDES:
                return FeatureType.PROVIDES_SUBPROGRAM_GROUP_ACCESS;
            case REQUIRES:
                return FeatureType.REQUIRES_SUBPROGRAM_GROUP_ACCESS;
        }
    } else if (el instanceof ThreadGroup) {
        return FeatureType.THREAD_GROUP;
    } else if (el instanceof SystemSubcomponent) {
        return FeatureType.SYSTEM_SUBCOMPONENT;
    } else if (el instanceof SubprogramSubcomponent) {
        return FeatureType.SUBPROGRAM_SUBCOMPONENT;
    } else if (el instanceof SubprogramClassifier) {
        return FeatureType.SUBPROGRAM_CLASSIFIER;
    } else if (el instanceof DataSubcomponent) {
        return FeatureType.DATA_SUBCOMPONENT;
    } else if (el instanceof DataClassifier) {
        return FeatureType.DATA_CLASSIFIER;
    } else if (el instanceof ProcessorClassifier) {
        return FeatureType.PROCESSOR_CLASSIFIER;
    } else if (el instanceof ProcessClassifier) {
        return FeatureType.PROCESS_CLASSIFIER;
    }
    String errorMsg = "getFeatureType : " + el.getClass().getSimpleName() + " is not supported yet at line " + Aadl2Utils.getLocationReference(el).getLine() + ".";
    System.err.println(errorMsg);
    throw new UnsupportedOperationException(errorMsg);
}

Example 28 with ClassifierValue

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

the class AadlBaNameResolver method propertyExpressionResolver.

/**
 * Resolves the property expressions used in behavior annex.
 * @param p
 *
 * @return {@code true} if all names are resolved. {@code false} otherwise.
 */
private boolean propertyExpressionResolver(BehaviorVariable bv, Property p, PropertyExpression pe) {
    QualifiedNamedElement qne = (QualifiedNamedElement) p;
    String propertyName = "";
    boolean hasNamespace = qne.getBaNamespace() != null;
    if (hasNamespace) {
        propertyName = qne.getBaNamespace().getId() + "::";
    }
    propertyName += qne.getBaName().getId();
    boolean result = true;
    if (pe instanceof DeclarativeListValue) {
        ListValue dlv = (DeclarativeListValue) pe;
        for (PropertyExpression peInList : dlv.getOwnedListElements()) {
            result &= propertyExpressionResolver(bv, p, peInList);
        }
    } else if (pe instanceof IntegerLiteral) {
        IntegerLiteral il = (IntegerLiteral) pe;
        if (il.getUnit() != null && il.getUnit() instanceof QualifiedNamedElement) {
            result &= unitResolver(il, bv, p);
        }
    } else if (pe instanceof RealLiteral) {
        RealLiteral rl = (RealLiteral) pe;
        if (rl.getUnit() != null && rl.getUnit() instanceof QualifiedNamedElement) {
            result &= unitResolver(rl, bv, p);
        }
    } else if (pe instanceof RecordValue) {
        RecordValue rv = (RecordValue) pe;
        for (BasicPropertyAssociation bpa : rv.getOwnedFieldValues()) {
            if (bpa instanceof DeclarativeBasicPropertyAssociation) {
                DeclarativeBasicPropertyAssociation dbpa = (DeclarativeBasicPropertyAssociation) bpa;
                String basicPropertyName = dbpa.getBasicPropertyName();
                BasicProperty basicProp = getBasicPropertyResolver(bv, p, basicPropertyName);
                if (basicProp == null) {
                    _errManager.error(bv, "Property field \'" + basicPropertyName + "\' of property " + propertyName + " is not found");
                    result = false;
                }
                dbpa.setProperty(basicProp);
            }
        }
    } else if (pe instanceof RangeValue) {
        RangeValue rv = (RangeValue) pe;
        result &= propertyExpressionResolver(bv, p, rv.getMaximum());
        result &= propertyExpressionResolver(bv, p, rv.getMinimum());
    } else if (pe instanceof ReferenceValue) {
        ReferenceValue rv = (ReferenceValue) pe;
        Reference r = (Reference) (rv.getPath());
        ContainmentPathElement firstCne = Aadl2Factory.eINSTANCE.createContainmentPathElement();
        ContainmentPathElement prevCne = null;
        boolean first = true;
        Classifier context = _baParentContainer;
        for (Identifier subPath : r.getIds()) {
            ContainmentPathElement currentCne;
            if (!first) {
                currentCne = Aadl2Factory.eINSTANCE.createContainmentPathElement();
            } else {
                currentCne = firstCne;
            }
            first = false;
            NamedElement ne = Aadl2Visitors.findSubcomponentInComponent(context, subPath.getId());
            if (ne == null) {
                ne = Aadl2Visitors.findFeatureInComponent(context, subPath.getId());
            }
            if (ne == null) {
                _errManager.error(bv, "Element \'" + subPath.getId() + "\' is not found in " + context.getName() + "(property " + propertyName + ")");
                result = false;
            } else {
                currentCne.setNamedElement(ne);
                if (prevCne != null) {
                    prevCne.setPath(currentCne);
                }
                if (ne instanceof Subcomponent) {
                    Subcomponent sub = (Subcomponent) ne;
                    context = sub.getClassifier();
                } else if (ne instanceof Feature) {
                    Feature f = (Feature) ne;
                    context = f.getClassifier();
                }
            }
            prevCne = currentCne;
        }
        rv.setPath(firstCne);
    } else if (pe instanceof ClassifierValue) {
        ClassifierValue cv = (ClassifierValue) pe;
        QualifiedNamedElement classifierQne = (QualifiedNamedElement) cv.getClassifier();
        String qneClassPackageName = "";
        boolean qneClassHasNamespace = classifierQne.getBaNamespace() != null;
        if (qneClassHasNamespace) {
            qneClassPackageName = classifierQne.getBaNamespace().getId();
        }
        boolean resolved = false;
        for (PackageSection context : _contextsTab) {
            NamedElement ne = Aadl2Visitors.findElementInPackage(classifierQne.getBaName().getId(), qneClassPackageName, context);
            if (ne != null && ne instanceof Classifier) {
                cv.setClassifier((Classifier) ne);
                resolved = true;
                break;
            }
        }
        if (!resolved) {
            String cvQualifiedName = "";
            if (!qneClassPackageName.isEmpty()) {
                cvQualifiedName += qneClassPackageName + "::";
            }
            cvQualifiedName += classifierQne.getBaName().getId();
            _errManager.error(bv, "Classifier \'" + cvQualifiedName + "\' associated to property " + propertyName + " is not found");
            result = false;
        }
    }
    return result;
}

Example 29 with ClassifierValue

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

the class DeploymentProperties method getRequiredVirtualBusClass.

public static Optional<List<Classifier>> getRequiredVirtualBusClass(NamedElement lookupContext, Optional<Mode> mode) {
    Property property = getRequiredVirtualBusClass_Property(lookupContext);
    try {
        PropertyExpression value = CodeGenUtil.lookupProperty(property, lookupContext, mode);
        PropertyExpression resolved = CodeGenUtil.resolveNamedValue(value, lookupContext, mode);
        return Optional.of(((ListValue) resolved).getOwnedListElements().stream().map(element1 -> {
            PropertyExpression resolved1 = CodeGenUtil.resolveNamedValue(element1, lookupContext, mode);
            return ((ClassifierValue) resolved1).getClassifier();
        }).collect(Collectors.toList()));
    } catch (PropertyNotPresentException e) {
        return Optional.empty();
    }
}

Example 30 with ClassifierValue

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

the class PropertyUtils method getClassifierValue.

/**
 * TODO: DOC ME !
 *
 * May return null.
 *
 * @param owner
 * @param propertyName
 * @return
 */
public static Classifier getClassifierValue(NamedElement owner, String propertyName) {
    PropertyAssociation pa = findPropertyAssociation(propertyName, owner);
    if (pa != null) {
        Property p = pa.getProperty();
        if (p.getName().equalsIgnoreCase(propertyName)) {
            List<ModalPropertyValue> values = pa.getOwnedValues();
            if (values.size() == 1) {
                ModalPropertyValue v = values.get(0);
                PropertyExpression expr = v.getOwnedValue();
                if (expr instanceof ClassifierValue) {
                    return ((ClassifierValue) expr).getClassifier();
                }
            }
        }
    }
    return null;
}