use of org.osate.aadl2.Operation in project osate2 by osate.
the class CreatePropagatonPathPaletteCommand method getOperation.
@Override
public Optional<Operation> getOperation(final GetCreateConnectionOperationContext ctx) {
// Check the type of the destination business object
if (!isValidEndpoint(ctx.getDestination())) {
return Optional.empty();
}
// Find the common ancestor which is a source for the classifier to update
final BusinessObjectContext classifierSourceBoc = BusinessObjectContext.getFirstCommonAncestor(ctx.getSource().getParent(), ctx.getDestination().getParent()).flatMap(ancestor -> ErrorModelGeUtil.getClassifierSourceBoc(ancestor)).orElse(null);
if (classifierSourceBoc == null) {
return Optional.empty();
}
return ErrorModelGeUtil.createErrorModelSubclauseModifyOperation(classifierSourceBoc, subclause -> {
final PropagationPath newPath = ErrorModelFactory.eINSTANCE.createPropagationPath();
final String newName = ErrorModelNamingUtil.buildUniqueIdentifier(subclause.getContainingClassifier(), "new_propagation_path");
newPath.setName(newName);
newPath.setSource(createQualifiedPropagationPoint(subclause, ctx.getSource(), classifierSourceBoc));
newPath.setTarget(createQualifiedPropagationPoint(subclause, ctx.getDestination(), classifierSourceBoc));
subclause.getPaths().add(newPath);
return StepResultBuilder.create().showNewBusinessObject(classifierSourceBoc, newPath).build();
});
}
use of org.osate.aadl2.Operation in project osate2 by osate.
the class CreateErrorPathPaletteCommand method getOperation.
@Override
public Optional<Operation> getOperation(final GetCreateConnectionOperationContext ctx) {
// Check if the destination is a potential end
if (!ErrorFlowPaletteCommandUtil.isPotentialEnd(ctx.getDestination())) {
return Optional.empty();
}
// Find the common ancestor which is a source for the classifier to update
final BusinessObjectContext classifierSourceBoc = BusinessObjectContext.getFirstCommonAncestor(ctx.getSource().getParent(), ctx.getDestination().getParent()).flatMap(ancestor -> ErrorModelGeUtil.getClassifierSourceBoc(ancestor)).orElse(null);
if (classifierSourceBoc == null) {
return Optional.empty();
}
return ErrorModelGeUtil.createErrorModelSubclausePromptAndModifyOperation(classifierSourceBoc, () -> {
final CombinedErrorModelSubclause combined = CombinedErrorModelSubclause.create(ErrorModelGeUtil.getClassifier(classifierSourceBoc).get());
// Validate both the source and the destination
return (ErrorFlowPaletteCommandUtil.validateAndShowError(combined, ctx.getSource(), DirectionType.IN) && ErrorFlowPaletteCommandUtil.validateAndShowError(combined, ctx.getDestination(), DirectionType.OUT)) ? Optional.of(true) : Optional.empty();
}, (subclause, unused) -> {
final ErrorPath newFlow = ErrorModelFactory.eINSTANCE.createErrorPath();
// Set name
final String newName = ErrorModelNamingUtil.buildUniqueIdentifier(subclause.getContainingClassifier(), "new_error_flow");
newFlow.setName(newName);
// Set the incoming and outgoing fields of the flow
final CombinedErrorModelSubclause combined = CombinedErrorModelSubclause.create(subclause.getContainingClassifier());
final boolean allSrc = ErrorFlowPaletteCommandUtil.isAll(ctx.getSource());
if (allSrc) {
newFlow.setAllIncoming(allSrc);
} else {
newFlow.setIncoming(ErrorFlowPaletteCommandUtil.findErrorPropagationOrThrow(combined, ctx.getSource(), DirectionType.IN));
}
final boolean allDst = ErrorFlowPaletteCommandUtil.isAll(ctx.getDestination());
if (allDst) {
newFlow.setAllOutgoing(allDst);
} else {
newFlow.setOutgoing(ErrorFlowPaletteCommandUtil.findErrorPropagationOrThrow(combined, ctx.getDestination(), DirectionType.OUT));
}
// Add the flow to the subclause
subclause.getFlows().add(newFlow);
return StepResultBuilder.create().showNewBusinessObject(classifierSourceBoc, newFlow).build();
});
}
use of org.osate.aadl2.Operation in project osate2 by osate.
the class CreateErrorPropagationPaletteCommand method getOperation.
@Override
public Optional<Operation> getOperation(final GetTargetedOperationContext ctx) {
final Object bo = ctx.getTarget().getBusinessObject();
if (bo instanceof Feature) {
return createPropgationCreationOperation(ctx.getTarget(), (newPropagation, subclause) -> {
// Find the feature in the context of the EMV subclause. This is needed for reliable serialization.
final List<URI> path = ErrorModelGeUtil.createQualifiedPropagationPointPath(ctx.getTarget(), ErrorModelGeUtil.getClassifierSourceBoc(ctx.getTarget()).get(), new ArrayList<>());
newPropagation.setFeatureorPPRef(buildFeatureReference(subclause.eResource().getResourceSet(), path));
});
} else if (bo instanceof KeywordPropagationPoint) {
final KeywordPropagationPoint kw = (KeywordPropagationPoint) bo;
if (kw.getType() != KeywordPropagationPointType.ALL) {
return createPropgationCreationOperation(ctx.getTarget(), (newPropagation, subclause) -> newPropagation.setKind(kw.getType().getKind()));
}
} else if (bo instanceof PropagationPoint) {
return createPropgationCreationOperation(ctx.getTarget(), (newPropagation, subclause) -> {
// Find the propagation in the context of the EMV subclause.
// Check inherited subclauses as well. This is needed for reliable serialization.
final CombinedErrorModelSubclause combined = CombinedErrorModelSubclause.create(subclause.getContainingClassifier());
final String boName = ((PropagationPoint) bo).getName();
final PropagationPoint pp = combined.getPoints().filter(p -> Objects.equal(p.getName(), boName)).findAny().orElseThrow(() -> new AadlGraphicalEditorException("Unable to find propagation point"));
final FeatureorPPReference ppRef = ErrorModelFactory.eINSTANCE.createFeatureorPPReference();
ppRef.setFeatureorPP(pp);
newPropagation.setFeatureorPPRef(ppRef);
});
}
return Optional.empty();
}
use of org.osate.aadl2.Operation in project osate2 by osate.
the class CreateErrorPropagationPaletteCommand method createPropgationCreationOperation.
/**
* Creates an operation for creating a propagation for the target.
* @param target is the target of the propagation. It should be the context which will be the parent of the propagation
* @param init function called to finish initializing the propagation. It must set the kind or the feature or PP reference.
* @return the operation or an empty optional if a classifier could not be determined.
*/
private Optional<Operation> createPropgationCreationOperation(final BusinessObjectContext target, final BiConsumer<ErrorPropagation, ErrorModelSubclause> init) {
return ErrorModelGeUtil.getClassifierSourceBoc(target).flatMap(container -> {
final AadlPackage pkg = container.getBusinessObject(NamedElement.class).map(ne -> ne.getElementRoot()).map(root -> root instanceof AadlPackage ? ((AadlPackage) root) : null).orElseThrow(() -> new AadlGraphicalEditorException("Unable to find model"));
return ErrorModelGeUtil.createErrorModelSubclausePromptAndModifyOperation(container, () -> {
if (propagationAlreadyExists(target)) {
final String propagationOrContainmentLabel = (containment ? "containment" : "propagation");
final String inputOrOutputLabel = direction == DirectionType.IN ? "intput" : "output";
MessageDialog.openError(Display.getDefault().getActiveShell(), "Unable to create " + propagationOrContainmentLabel, "Propagation already exists. A propagation point may only have one " + inputOrOutputLabel + " error " + propagationOrContainmentLabel + " defined.");
return Optional.empty();
}
return ErrorModelUiUtil.promptForTypeSet(pkg);
}, (subclause, typeSet) -> {
final ErrorPropagation newPropagation = ErrorModelFactory.eINSTANCE.createErrorPropagation();
newPropagation.setTypeSet(typeSet);
newPropagation.setNot(containment);
newPropagation.setDirection(direction);
init.accept(newPropagation, subclause);
subclause.getPropagations().add(newPropagation);
return StepResultBuilder.create().showNewBusinessObject(target, newPropagation).build();
});
});
}
use of org.osate.aadl2.Operation in project osate2 by osate.
the class AadlBaTypeChecker method subprogramParameterListCheck.
// This method checks the given parameter labels and matches them against the
// subprogram parameters. It resolves target/value expression semantic
// ambiguities. On error, reports error and returns false.
// Event if the subprogram call action doesn't have any parameter labels,
// the subprogram type may have and vice versa : subprogramParameterListCheck
// / is also design for these cases.
/**
* Document: AADL Behavior Annex draft
* Version : 0.94
* Type : Legality rule
* Section : D.6 Behavior Action Language
* Object : Check legality rule D.6.(L5)
* Keys : parameter list match signature subprogram call
*/
private boolean subprogramParameterListCheck(CommAction comAct, EList<ParameterLabel> callParams, Classifier subprogType) {
// Fetches sorted subprogram feature list.
List<Feature> tmp = Aadl2Utils.orderFeatures(subprogType);
List<Feature> subprogFeat = new ArrayList<Feature>(tmp.size());
for (Feature feat : tmp) {
if (feat instanceof DataAccess || feat instanceof Parameter) {
subprogFeat.add(feat);
}
}
// Preliminary checking : on error, reports error and exit early.
if (callParams.size() != subprogFeat.size()) {
String subprogramName = null;
if (comAct.getReference() != null) {
subprogramName = unparseReference(comAct.getReference());
} else {
subprogramName = unparseQualifiedNamedElement(comAct.getQualifiedName());
}
reportError(comAct, "Invalid number of argument(s) for the subprogram " + subprogramName);
return false;
}
boolean isconsistent = true;
boolean hasCheckingPassed = true;
Enum<?> currentDirRight;
ValueExpression valueExp;
ListIterator<ParameterLabel> it = callParams.listIterator();
Value v;
Target tar;
TypeHolder t1, t2;
ValueAndTypeHolder vth;
List<TypeHolder> typesFound = new ArrayList<TypeHolder>(callParams.size());
List<Enum<?>> dirRightsFound = new ArrayList<Enum<?>>(callParams.size());
List<TypeHolder> expectedTypes = new ArrayList<TypeHolder>(subprogFeat.size());
List<Enum<?>> expectedDirRight = new ArrayList<Enum<?>>(subprogFeat.size());
// driven by the subprogram signature.
for (Feature feat : subprogFeat) {
if (feat instanceof Parameter) {
Parameter param = (Parameter) feat;
currentDirRight = param.getDirection();
expectedDirRight.add(currentDirRight);
} else // DataAccess case.
{
DataAccess data = (DataAccess) feat;
currentDirRight = Aadl2Utils.getDataAccessRight(data);
expectedDirRight.add(currentDirRight);
}
valueExp = (ValueExpression) it.next();
Classifier klass = AadlBaUtils.getClassifier(feat, _baParentContainer);
// ValueExpression case.
if (currentDirRight == DirectionType.IN || currentDirRight == Aadl2Utils.DataAccessRight.read_only) {
vth = valueExpressionCheck(valueExp);
if (vth != null) {
try {
t1 = AadlBaUtils.getTypeHolder(klass);
} catch (DimensionException de) {
reportDimensionException(de);
return false;
}
t2 = vth.typeHolder;
expectedTypes.add(t1);
typesFound.add(t2);
dirRightsFound.add(DirectionType.IN);
if (!_dataChecker.conformsTo(t1, t2, true)) {
isconsistent = false;
}
} else // Value expression checking error case.
{
// Error reporting has already been done.
hasCheckingPassed = false;
}
} else if (currentDirRight != Aadl2Utils.DataAccessRight.unknown) {
v = AadlBaUtils.isOnlyOneValue(valueExp);
boolean isOnlyOneReference = false;
if (v instanceof Reference) {
Reference r = (Reference) v;
if (r.getIds().size() == 1) {
isOnlyOneReference = true;
}
}
if (// Target but not reference case.
v instanceof Target && isOnlyOneReference) {
TypeCheckRule stopOnThisRule = TypeCheckRule.DATA_ACCESS;
tar = targetCheck((Target) v, stopOnThisRule);
if (tar != null) {
try {
t1 = AadlBaUtils.getTypeHolder(klass);
t2 = AadlBaUtils.getTypeHolder(tar, _baParentContainer);
} catch (DimensionException de) {
reportDimensionException(de);
return false;
}
expectedTypes.add(t1);
typesFound.add(t2);
Enum<?> dirRightFound = AadlBaUtils.getDirectionType(tar);
if (dirRightFound == null) {
dirRightFound = AadlBaUtils.getDataAccessRight(tar);
}
dirRightsFound.add(dirRightFound);
if (!_dataChecker.conformsTo(t1, t2, true)) {
isconsistent = false;
} else {
// As checking passed and ambiguity between
// ValueExpression and Target has been resolved, it replaces
// the value expression by the target as parameter label.
it.set(tar);
}
} else // Target checking error case.
{
// Error reporting has already been done.
hasCheckingPassed = false;
}
} else // Value expression taken as a target -> warning arithmetic pointer operation.
{
// Due to target/value expression semantic ambiguity, the parsing
// phase may have introduced a semantic errors :
// If v == null :
// The parameter label has
// to be a value expression with a single value when the expected
// subprogram parameter is IN_OUT or OUT.
// If v is not instanceof Target but ValueExpression or Value
// like :
// _ IntegerConstant or ValueConstant
// _ PortFreshValue
// _ PortCountValue
// _ PortDequeueValue
// It resolves the type in order to format the warning message:
vth = valueExpressionCheck(valueExp);
if (vth != null) {
try {
t1 = AadlBaUtils.getTypeHolder(klass);
} catch (DimensionException de) {
reportDimensionException(de);
return false;
}
t2 = vth.typeHolder;
expectedTypes.add(t1);
typesFound.add(t2);
boolean inconsistentDir = false;
if (v instanceof Reference) {
Reference ref = (Reference) v;
ArrayableIdentifier refRootId = ref.getIds().get(0);
Enum<?> dirRightFound = null;
if (refRootId.getOsateRef() != null) {
dirRightFound = AadlBaUtils.getDirectionType(refRootId.getOsateRef());
}
if (dirRightFound == null && refRootId.getOsateRef() instanceof DataAccess) {
dirRightFound = Aadl2Utils.getDataAccessRight((DataAccess) refRootId.getOsateRef());
}
if (dirRightFound == DirectionType.IN || dirRightFound == Aadl2Utils.DataAccessRight.read_only) {
inconsistentDir = true;
}
} else {
inconsistentDir = true;
dirRightsFound.add(DirectionType.IN);
}
if (inconsistentDir) {
StringBuilder msg = new StringBuilder();
msg.append('\'');
msg.append(unparseNameElement(valueExp));
msg.append("\': is a read only value and it is used as a writable value");
// Reports a warning.
reportWarning(valueExp, msg.toString());
}
} else {
// Error reporting has already been done.
hasCheckingPassed = false;
}
}
} else {
reportError(valueExp, "can't fetch data access right. Set the default " + "right in memory_properties.aadl");
}
}
// Reports consistency error.
if (!isconsistent && hasCheckingPassed) {
String subprogramName = null;
if (comAct.getReference() != null) {
subprogramName = unparseReference(comAct.getReference());
} else {
subprogramName = unparseQualifiedNamedElement(comAct.getQualifiedName());
}
reportSubprogParamMatchingError(comAct, subprogramName, expectedTypes, expectedDirRight, typesFound, dirRightsFound);
}
return isconsistent && hasCheckingPassed;
}
Aggregations