Examples with ConnectionReference org.osate.aadl2.instance.ConnectionReference used on opensource projects

Example 36 with ConnectionReference

use of org.osate.aadl2.instance.ConnectionReference in project osate2 by osate.

the class EMV2Util method mapToken.

/**
 *  figure out the target typetoken based on the source and type mappings
 * Path can be a connection instance, a flow spec instance, or an error flow
 * If null or no mapping found, then use source type token
 * @param path connection instance, flow spec instance, error flow
 * @param path path of mapping
 * @return TypeToken
 */
public static TypeToken mapToken(TypeToken sourceToken, EObject path) {
    TypeToken result = sourceToken;
    if (path instanceof ConnectionInstance) {
        if (sourceToken != null) {
            // TODO lookup type transformations for connections and use them to determine target type
            ConnectionReference connref = Aadl2InstanceUtil.getTopConnectionReference((ConnectionInstance) path);
            ComponentInstance parentci = connref.getContext();
            TypeTransformationSet tts = getAllTypeTransformationSet(parentci);
            result = EMV2TypeSetUtil.mapTypeToken(sourceToken, tts);
        }
    } else if (path instanceof ErrorPath) {
        ErrorPath epath = (ErrorPath) path;
        // map the token
        TypeSet ttup = epath.getTargetToken();
        if (ttup == null) {
            // map token via tms
            TypeMappingSet tms = getUseMappings(epath);
            if (tms != null) {
                result = EMV2TypeSetUtil.mapTypeToken(sourceToken, tms);
            }
        } else {
            result = ttup.getTypeTokens().get(0);
        }
    } else if (path instanceof FlowSpecificationInstance) {
    // pass on source token
    }
    return result;
}

Example 37 with ConnectionReference

use of org.osate.aadl2.instance.ConnectionReference in project osate2 by osate.

the class ConnectionReferenceHandler method getGraphicalConfiguration.

@Override
public Optional<GraphicalConfiguration> getGraphicalConfiguration(final GetGraphicalConfigurationContext ctx) {
    final BusinessObjectContext boc = ctx.getBusinessObjectContext();
    final QueryService queryService = ctx.getQueryService();
    final ConnectionReference bo = boc.getBusinessObject(ConnectionReference.class).orElseThrow();
    final QueryResult srcResult = queryService.getFirstResult(SRC_QUERY, boc, bo).orElse(null);
    final QueryResult dstResult = queryService.getFirstResult(DST_QUERY, boc, bo).orElse(null);
    final boolean partial = (srcResult != null && srcResult.isPartial()) || (dstResult != null && dstResult.isPartial());
    final BusinessObjectContext src = srcResult == null ? null : srcResult.getBusinessObjectContext();
    final BusinessObjectContext dst = dstResult == null ? null : dstResult.getBusinessObjectContext();
    if (src == dst) {
        return Optional.empty();
    }
    // Don't display connection references when one endpoint is an ancestor of the other. This can happen for a subset of partial connections.
    if (src != null && dst != null) {
        for (BusinessObjectContext srcAncestor = src.getParent(); srcAncestor != null; srcAncestor = srcAncestor.getParent()) {
            if (srcAncestor == dst) {
                return Optional.empty();
            }
        }
        for (BusinessObjectContext dstAncestor = dst.getParent(); dstAncestor != null; dstAncestor = dstAncestor.getParent()) {
            if (dstAncestor == src) {
                return Optional.empty();
            }
        }
    }
    return Optional.of(GraphicalConfigurationBuilder.create().graphic(GRAPHIC).style(partial ? PARTIAL_STYLE : STYLE).source(src).destination(dst).build());
}

Example 38 with ConnectionReference

use of org.osate.aadl2.instance.ConnectionReference in project osate2 by osate.

the class ShowFlowContributionItem method createControl.

@Override
protected Control createControl(final Composite parent) {
    showFlowBtn = new Button(parent, SWT.PUSH);
    showFlowBtn.setImage(showIcon.createImage());
    showFlowBtn.setToolTipText("Show");
    updateButton();
    showFlowBtn.addSelectionListener(new SelectionAdapter() {

        private ProjectReferenceService referenceService;

        @Override
        public void widgetSelected(final SelectionEvent e) {
            if (editor != null && selectedFlow != null) {
                referenceService = Objects.requireNonNull(Adapters.adapt(editor, ProjectReferenceService.class), "Unable to retrieve reference service");
                final DiagramUpdater diagramUpdater = editor.getDiagramUpdater();
                final BusinessObjectTreeUpdater boTreeUpdater = editor.getBoTreeUpdater();
                final BusinessObjectNode boTree = getBoTree(boTreeUpdater);
                final BusinessObjectNode containerNode = boTree.getAllDescendants().filter(q -> q.getBusinessObject() == selectedFlow.getContainer().getBusinessObject()).findAny().map(BusinessObjectNode.class::cast).orElseThrow(() -> new RuntimeException("Cannot find container for highlightable flow: " + selectedFlow.getFlowSegment().getName()));
                final Object component = getContainerComponent(selectedFlow.getContainer().getBusinessObject());
                ensureFlowSegmentsExist(component, selectedFlow.getFlowSegment(), containerNode);
                final AgeDiagram diagram = editor.getDiagram();
                final LayoutInfoProvider layoutInfoProvider = Objects.requireNonNull(Adapters.adapt(editor, LayoutInfoProvider.class), "Unable to retrieve layout info provider");
                editor.getActionExecutor().execute("Show Flow Elements", ExecutionMode.NORMAL, () -> {
                    // Update the diagram
                    diagramUpdater.updateDiagram(diagram, boTree);
                    // Update layout
                    diagram.modify("Layout Incrementally", m -> DiagramElementLayoutUtil.layoutIncrementally(diagram, m, layoutInfoProvider));
                    return null;
                });
            }
        }

        private List<FlowSegmentReference> findFlowSegments(final FlowSegmentReference flowElementRef) {
            if (flowElementRef.flowSegmentElement instanceof FlowSpecification) {
                // Check if flow specification has flow implementation(s)
                return AadlClassifierUtil.getComponentImplementation(flowElementRef.container.getBusinessObject()).map(ci -> ci.getAllFlowImplementations().stream().filter(cfi -> flowElementRef.flowSegmentElement == cfi.getSpecification()).flatMap(cfi -> cfi.getOwnedFlowSegments().stream()).map(flowSegment -> createFlowSegmentReference(flowSegment, (BusinessObjectNode) flowElementRef.container))).orElse(Stream.empty()).collect(Collectors.toList());
            } else if (flowElementRef.flowSegmentElement instanceof EndToEndFlow) {
                final EndToEndFlow endToEndFlow = (EndToEndFlow) flowElementRef.flowSegmentElement;
                final BusinessObjectNode containerNode = (BusinessObjectNode) flowElementRef.container;
                return AadlClassifierUtil.getComponentImplementation(containerNode.getBusinessObject()).map(ci -> ci.getAllEndToEndFlows().stream().filter(ownedEndToEndFlow -> ownedEndToEndFlow == endToEndFlow).flatMap(ete -> ete.getAllFlowSegments().stream().flatMap(flowSegment -> {
                    final EndToEndFlowElement endToEndFlowElement = flowSegment.getFlowElement();
                    if (endToEndFlowElement instanceof EndToEndFlow) {
                        // Find segments of a segment that is an end to end flow
                        return ((EndToEndFlow) endToEndFlowElement).getAllFlowSegments().stream();
                    }
                    return Stream.of(flowSegment);
                })).map(endToEndFlowSegment -> createFlowSegmentReference(endToEndFlowSegment, containerNode))).orElse(Stream.empty()).collect(Collectors.toList());
            } else if (flowElementRef.flowSegmentElement instanceof EndToEndFlowInstance) {
                return AadlInstanceObjectUtil.getComponentInstance(flowElementRef.container.getBusinessObject()).map(ci -> ci.getEndToEndFlows().stream().filter(ete -> ete == flowElementRef.flowSegmentElement).flatMap(ete -> {
                    return ete.getFlowElements().stream().flatMap(fei -> {
                        if (fei instanceof ConnectionInstance) {
                            return ((ConnectionInstance) fei).getConnectionReferences().stream().map(cr -> createFlowSegmentReference(cr, (BusinessObjectNode) flowElementRef.container));
                        } else {
                            return Stream.of(createFlowSegmentReference(fei, (BusinessObjectNode) flowElementRef.container));
                        }
                    });
                })).orElse(Stream.empty()).collect(Collectors.toList());
            } else {
                return Collections.emptyList();
            }
        }

        private void ensureFlowSegmentsExist(final Object component, final NamedElement flow, final BusinessObjectNode containerNode) {
            if (component instanceof ComponentImplementation) {
                final ComponentImplementation ci = (ComponentImplementation) component;
                if (flow instanceof FlowSpecification) {
                    ci.getAllFlowImplementations().stream().filter(fi -> flow.getName().equalsIgnoreCase(fi.getSpecification().getName())).findAny().ifPresent(flowImpl -> {
                        final FlowSegmentReference flowSegmentRef = createFlowSegmentReference(flowImpl.getSpecification(), containerNode);
                        enableFlowSegments(findFlowSegments(flowSegmentRef));
                    });
                } else {
                    final String eteName = flow.getName();
                    final Optional<EndToEndFlow> eteFlow = ci.getAllEndToEndFlows().stream().filter(etef -> eteName.equalsIgnoreCase(etef.getName())).findAny();
                    eteFlow.ifPresent(endToEndFlow -> {
                        final FlowSegmentReference flowSegmentRef = createFlowSegmentReference(endToEndFlow, containerNode);
                        enableFlowSegments(findFlowSegments(flowSegmentRef));
                    });
                }
            } else if (component instanceof ComponentInstance) {
                // ETE Flows only
                final EndToEndFlowInstance eteFlowInstance = (EndToEndFlowInstance) flow;
                final FlowSegmentReference flowSegmentRef = createFlowSegmentReference(eteFlowInstance, containerNode);
                enableFlowSegments(findFlowSegments(flowSegmentRef));
            }
        }

        private void enableFlowSegments(final List<FlowSegmentReference> highlightableFlowElements) {
            highlightableFlowElements.stream().filter(Predicates.notNull()).forEach(highlightableFlowElement -> {
                final NamedElement flowSegmentElement = highlightableFlowElement.flowSegmentElement;
                final BusinessObjectContext flowSegmentContainer = highlightableFlowElement.container;
                // Find segments for flow and remove cycles
                final List<FlowSegmentReference> flowSegmentReferences = findFlowSegments(highlightableFlowElement).stream().filter(flowSegmentReference -> flowSegmentReference.flowSegmentElement != flowSegmentElement && flowSegmentReference.container != flowSegmentContainer).collect(Collectors.toList());
                enableFlowSegments(flowSegmentReferences);
            });
        }

        private Object getContainerComponent(final Object container) {
            if (container instanceof Subcomponent) {
                final Subcomponent sc = (Subcomponent) container;
                return sc.getComponentImplementation();
            }
            return container;
        }

        private BusinessObjectNode getBoTree(final BusinessObjectTreeUpdater treeUpdater) {
            BusinessObjectNode boTree = DiagramToBusinessObjectTreeConverter.createBusinessObjectNode(editor.getDiagram());
            return treeUpdater.updateTree(editor.getDiagram().getConfiguration(), boTree);
        }

        private FlowSegmentReference createFlowSegmentReference(final Object bo, final BusinessObjectNode container) {
            if (bo instanceof FlowSegment) {
                final FlowSegment flowSegment = (FlowSegment) bo;
                final FlowElement flowElement = flowSegment.getFlowElement();
                if (flowSegment.getContext() == null) {
                    return createFlowSegmentReference(flowElement, container);
                } else {
                    final BusinessObjectNode contextNode = ensureEnabledChild(flowSegment.getContext(), container);
                    return createFlowSegmentReference(flowElement, contextNode);
                }
            } else if (bo instanceof EndToEndFlowSegment) {
                final EndToEndFlowSegment flowSegment = (EndToEndFlowSegment) bo;
                if (flowSegment.getFlowElement() instanceof FlowElement) {
                    final FlowElement flowElement = (FlowElement) flowSegment.getFlowElement();
                    if (flowSegment.getContext() == null) {
                        return createFlowSegmentReference(flowElement, container);
                    } else {
                        final BusinessObjectNode contextNode = ensureEnabledChild(flowSegment.getContext(), container);
                        return createFlowSegmentReference(flowElement, contextNode);
                    }
                }
                return createFlowSegmentReference(flowSegment.getFlowElement(), container);
            } else if (bo instanceof InstanceObject) {
                final InstanceObject io = (InstanceObject) bo;
                if (bo instanceof EndToEndFlowInstance) {
                    return new FlowSegmentReference(io, container);
                } else {
                    final Map<Object, BusinessObjectContext> descendantBoToQueryable = container.getAllDescendants().collect(Collectors.toMap(BusinessObjectContext::getBusinessObject, Function.identity()));
                    if (bo instanceof FlowSpecificationInstance) {
                        final FlowSpecificationInstance fsi = (FlowSpecificationInstance) bo;
                        enableFlowSpecificationInstanceNodes(descendantBoToQueryable, fsi);
                    }
                    if (bo instanceof ConnectionReference) {
                        final ConnectionReference cr = (ConnectionReference) bo;
                        enableConnectionReferenceNodes(descendantBoToQueryable, cr);
                    }
                    return new FlowSegmentReference(io, container);
                }
            } else if (bo instanceof NamedElement) {
                final RelativeBusinessObjectReference ref = getRelativeBusinessObjectReference(bo);
                if (ref != null) {
                    ensureEnabledChild(bo, container);
                }
                if (bo instanceof FlowSpecification) {
                    final FlowSpecification fs = (FlowSpecification) bo;
                    if (fs.getAllInEnd() != null) {
                        enableFlowEnd(fs.getAllInEnd(), container);
                    }
                    if (fs.getAllOutEnd() != null) {
                        enableFlowEnd(fs.getAllOutEnd(), container);
                    }
                } else if (bo instanceof Connection) {
                    final Connection connection = (Connection) bo;
                    final ConnectionEnd dstEnd = connection.getAllDestination();
                    final Context dstContext = connection.getAllDestinationContext();
                    final RelativeBusinessObjectReference dstEndRef = getRelativeBusinessObjectReference(dstEnd);
                    // Destination context
                    BusinessObjectNode ctxContainer = getContextContainer(dstContext, container);
                    if (ctxContainer.getChild(dstEndRef) == null) {
                        createNode(ctxContainer, dstEndRef, dstEnd);
                    }
                    final ConnectionEnd srcEnd = connection.getAllSource();
                    final Context srcContext = connection.getAllSourceContext();
                    // Source context
                    ctxContainer = getContextContainer(srcContext, container);
                    final RelativeBusinessObjectReference srcEndRef = getRelativeBusinessObjectReference(srcEnd);
                    if (ctxContainer.getChild(srcEndRef) == null) {
                        createNode(ctxContainer, srcEndRef, srcEnd);
                    }
                }
                return new FlowSegmentReference((NamedElement) bo, container);
            } else {
                throw new RuntimeException("Unexpected business object: " + bo);
            }
        }

        private BusinessObjectNode getContextContainer(final Context context, final BusinessObjectNode contextContainer) {
            if (context != null) {
                // Ensure context container is created
                final RelativeBusinessObjectReference contextRef = getRelativeBusinessObjectReference(context);
                if (contextContainer.getChild(contextRef) == null) {
                    // Show context
                    createNode(contextContainer, contextRef, context);
                }
                return contextContainer.getChild(contextRef);
            }
            return contextContainer;
        }

        private void enableFlowEnd(final FlowEnd flowEnd, BusinessObjectNode containerNode) {
            final Feature feature = (Feature) flowEnd.getFeature();
            if (flowEnd.getContext() != null) {
                containerNode = ensureEnabledChild(flowEnd.getContext(), containerNode);
            }
            ensureEnabledChild(feature, containerNode);
        }

        private void enableFlowSpecificationInstanceNodes(final Map<Object, BusinessObjectContext> descendantBoToQueryable, final FlowSpecificationInstance fsi) {
            enableAncestorNodes(descendantBoToQueryable, fsi);
            if (fsi.getDestination() != null) {
                enableAncestorNodes(descendantBoToQueryable, fsi.getDestination());
            }
            if (fsi.getSource() != null) {
                enableAncestorNodes(descendantBoToQueryable, fsi.getSource());
            }
        }

        private void enableConnectionReferenceNodes(final Map<Object, BusinessObjectContext> descendantBoToQueryable, final ConnectionReference cr) {
            Element tmpElement = cr;
            // Ancestors to ensure are enabled on the diagram
            final Queue<Element> ancestors = Collections.asLifoQueue(new LinkedList<Element>());
            if (!descendantBoToQueryable.containsKey(tmpElement)) {
                ancestors.add(tmpElement);
                tmpElement = tmpElement.getOwner();
                // First owner of connection reference is connection instance
                if (tmpElement instanceof ConnectionInstance) {
                    tmpElement = tmpElement.getOwner();
                }
            }
            // Connection reference
            populateAncestorsQueue(descendantBoToQueryable, ancestors, tmpElement);
            enableAncestorNodes(descendantBoToQueryable, ancestors, ancestors.poll());
            // Enable source and destination nodes
            enableAncestorNodes(descendantBoToQueryable, cr.getSource());
            enableAncestorNodes(descendantBoToQueryable, cr.getDestination());
        }

        // Gets the first element ancestor that is enabled
        private void populateAncestorsQueue(final Map<Object, BusinessObjectContext> descendantBoToQueryable, final Queue<Element> ancestors, Element ancestor) {
            while (!descendantBoToQueryable.containsKey(ancestor)) {
                ancestors.add(ancestor);
                ancestor = ancestor.getOwner();
            }
            ancestors.add(ancestor);
        }

        // Find ancestors and create if necessary
        private void enableAncestorNodes(final Map<Object, BusinessObjectContext> descendantBoToQueryable, final Element ancestor) {
            final Queue<Element> ancestors = Collections.asLifoQueue(new LinkedList<Element>());
            populateAncestorsQueue(descendantBoToQueryable, ancestors, ancestor);
            enableAncestorNodes(descendantBoToQueryable, ancestors, ancestors.poll());
        }

        // Create ancestor nodes
        private void enableAncestorNodes(final Map<Object, BusinessObjectContext> descendantBoToQueryable, final Queue<Element> ancestors, final Element ancestor) {
            BusinessObjectNode ancestorNode = (BusinessObjectNode) descendantBoToQueryable.get(ancestor);
            for (final Element ancestorToEnable : ancestors) {
                final RelativeBusinessObjectReference ancestorRef = getRelativeBusinessObjectReference(ancestorToEnable);
                if (ancestorNode.getChild(ancestorRef) == null) {
                    ancestorNode = createNode(ancestorNode, ancestorRef, ancestorToEnable);
                }
            }
        }

        private BusinessObjectNode ensureEnabledChild(final Object childBo, final BusinessObjectNode parent) {
            final RelativeBusinessObjectReference childRef = getRelativeBusinessObjectReference(childBo);
            final BusinessObjectNode childNode = parent.getChild(childRef);
            if (childRef != null && childNode == null) {
                return createNode(parent, childRef, childBo);
            }
            return Objects.requireNonNull(childNode, "Child node does not exist");
        }

        private BusinessObjectNode createNode(final BusinessObjectNode parent, final RelativeBusinessObjectReference childRef, final Object childBo) {
            return new BusinessObjectNode(parent, UUID.randomUUID(), childRef, childBo, Completeness.UNKNOWN, false);
        }

        private RelativeBusinessObjectReference getRelativeBusinessObjectReference(final Object bo) {
            final RelativeBusinessObjectReference result = referenceService.getRelativeReference(bo);
            return result;
        }
    });
    return showFlowBtn;
}

Example 39 with ConnectionReference

use of org.osate.aadl2.instance.ConnectionReference in project AGREE by loonwerks.

the class AgreeASTBuilder method getConnectionsFromInstances.

private List<AgreeAADLConnection> getConnectionsFromInstances(EList<ConnectionInstance> connectionInstances, ComponentInstance compInst, List<AgreeNode> subnodes, boolean latched) {
    List<AgreeAADLConnection> result = new ArrayList<>();
    for (ConnectionInstance connectionInstance : connectionInstances) {
        boolean isDelayed = isDelayed(connectionInstance, compInst);
        for (ConnectionReference connectionReference : connectionInstance.getConnectionReferences()) {
            ConnectionInstanceEnd sourceEndInstance = connectionReference.getSource();
            ConnectionInstanceEnd destinationEndInstance = connectionReference.getDestination();
            ComponentInstance sourceComponentInstance = sourceEndInstance.getComponentInstance();
            ComponentInstance destinationComponentInstance = destinationEndInstance.getComponentInstance();
            if (!compInst.equals(sourceComponentInstance) && !compInst.getComponentInstances().contains(sourceComponentInstance)) {
                // This connection reference connects to component instances not germane to this level of hierarchy
                continue;
            }
            if (!compInst.equals(destinationComponentInstance) && !compInst.getComponentInstances().contains(destinationComponentInstance)) {
                // This connection reference connects to component instances not germane to this level of hierarchy
                continue;
            }
            // make connections only to subcomponents that have annexes
            if (!compInst.equals(sourceComponentInstance) && compInst.getAllComponentInstances().contains(sourceComponentInstance)) {
                if (!AgreeUtils.containsTransitiveAgreeAnnex(sourceComponentInstance, isMonolithic)) {
                    continue;
                }
            }
            if (!compInst.equals(destinationComponentInstance) && compInst.getAllComponentInstances().contains(destinationComponentInstance)) {
                if (!AgreeUtils.containsTransitiveAgreeAnnex(destinationComponentInstance, isMonolithic)) {
                    continue;
                }
            }
            AgreeNode sourceNode = agreeNodeFromNamedEl(subnodes, sourceComponentInstance);
            AgreeNode destinationNode = agreeNodeFromNamedEl(subnodes, destinationComponentInstance);
            ConnectionEnd sourceConnectionEnd;
            if (sourceEndInstance instanceof FeatureInstance) {
                sourceConnectionEnd = ((FeatureInstance) sourceEndInstance).getFeature();
            } else {
                AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects from a " + sourceEndInstance.getClass().getName());
                continue;
            }
            ConnectionEnd destinationConnectionEnd;
            if (destinationEndInstance instanceof FeatureInstance) {
                destinationConnectionEnd = ((FeatureInstance) destinationEndInstance).getFeature();
            } else {
                AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects to a " + destinationEndInstance.getClass().getName());
                continue;
            }
            // TODO: Paranoia? Is this redundant with the previous lines?
            if (sourceConnectionEnd instanceof DataSubcomponent || destinationConnectionEnd instanceof DataSubcomponent) {
                AgreeLogger.logWarning("unable to reason about connection '" + connectionInstance.getQualifiedName() + "' because it connects to a data subcomponent");
                continue;
            }
            // Handle prefixing elements of feature groups
            String sourcePrefix = null;
            if (sourceConnectionEnd instanceof FeatureGroup) {
                sourcePrefix = sourceConnectionEnd.getName();
            }
            String destinationPrefix = null;
            if (destinationConnectionEnd instanceof FeatureGroup) {
                destinationPrefix = destinationConnectionEnd.getName();
            }
            List<AgreeVar> sourceVars = getAgreePortNames(sourceConnectionEnd, sourcePrefix, sourceNode == null ? null : sourceNode.compInst);
            List<AgreeVar> destinationVars = getAgreePortNames(destinationConnectionEnd, destinationPrefix, destinationNode == null ? null : destinationNode.compInst);
            if (sourceVars.size() != destinationVars.size()) {
                throw new AgreeException("The number of AGREE variables differ for connection '" + connectionInstance.getQualifiedName() + "'. Do the types of the source and destination differ? Perhaps one is an implementation and the other is a type?");
            }
            for (int i = 0; i < sourceVars.size(); i++) {
                AgreeVar sourceVar = sourceVars.get(i);
                AgreeVar destinationVar = destinationVars.get(i);
                if (!matches((ConnectionEnd) sourceVar.reference, (ConnectionEnd) destinationVar.reference)) {
                    AgreeLogger.logWarning("Connection '" + connectionInstance.getQualifiedName() + "' has ports '" + sourceVar.id.replace(dotChar, ".") + "' and '" + destinationVar.id.replace(dotChar, ".") + "' of differing type");
                    continue;
                }
                if (!sourceVar.type.equals(destinationVar.type)) {
                    throw new AgreeException("Type mismatch during connection generation");
                }
                ConnectionType connType;
                if (sourceVar.id.endsWith(eventSuffix)) {
                    connType = ConnectionType.EVENT;
                } else {
                    connType = ConnectionType.DATA;
                }
                AgreeAADLConnection agreeConnection = new AgreeAADLConnection(sourceNode, destinationNode, sourceVar, destinationVar, connType, latched, isDelayed, connectionReference.getConnection());
                result.add(agreeConnection);
            }
        }
    }
    return result;
}

Example 40 with ConnectionReference

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

the class Visitor method buildConnection.

private List<org.sireum.hamr.ir.Connection> buildConnection(ConnectionReference connRef, List<String> path, ComponentInstance compInst) {
    final Connection conn = connRef.getConnection();
    List<String> name = VisitorUtil.add(path, conn.getName());
    final ConnectionInstanceEnd scie = connRef.getSource();
    final ConnectionInstanceEnd dcie = connRef.getDestination();
    // List<org.sireum.hamr.ir.EndPoint> sep = buildEndPoint(sfii, path);
    // List<org.sireum.hamr.ir.EndPoint> dep = buildEndPoint(dcie, path);
    List<org.sireum.hamr.ir.EndPoint> src = VisitorUtil.iList();
    List<org.sireum.hamr.ir.EndPoint> dst = VisitorUtil.iList();
    if ((scie instanceof FeatureInstance) && (dcie instanceof FeatureInstance) && (((FeatureInstance) scie).getCategory() == ((FeatureInstance) dcie).getCategory())) {
        // src1 = buildEndPoint(conn.getSource(), path);
        // dst1 = buildEndPoint(conn.getDestination(), path);
        src = buildEndPoint(scie, path);
        dst = buildEndPoint(dcie, path);
    } else {
        src = buildEndPoint(conn.getSource(), path);
        dst = buildEndPoint(conn.getDestination(), path);
    }
    final boolean isBiDirectional = conn.isBidirectional();
    final List<ConnectionInstance> connInst = compInst.findConnectionInstance(conn);
    List<org.sireum.hamr.ir.Name> connectionInstances = VisitorUtil.iList();
    if (!connInst.isEmpty()) {
        connectionInstances = connInst.stream().map(ci -> factory.name(Arrays.asList(ci.getInstanceObjectPath().split("\\.")), VisitorUtil.buildPosInfo(ci))).collect(Collectors.toList());
    }
    AadlASTJavaFactory.ConnectionKind kind = null;
    if (conn instanceof AccessConnection) {
        kind = AadlASTJavaFactory.ConnectionKind.Access;
    } else if (conn instanceof FeatureGroupConnection) {
        kind = AadlASTJavaFactory.ConnectionKind.FeatureGroup;
    } else if (conn instanceof FeatureConnection) {
        kind = AadlASTJavaFactory.ConnectionKind.Feature;
    } else if (conn instanceof ParameterConnection) {
        kind = AadlASTJavaFactory.ConnectionKind.Parameter;
    } else if (conn instanceof PortConnection) {
        kind = AadlASTJavaFactory.ConnectionKind.Port;
    } else {
        throw new RuntimeException("Unexpected connection kind: " + conn);
    }
    if (src.size() == 1 && dst.size() == 1 && src.get(0).getFeature().nonEmpty() && dst.get(0).getFeature().nonEmpty() && (conn instanceof FeatureGroupConnection)) {
        scala.collection.immutable.Seq<org.sireum.String> srcNameSeq = src.get(0).getFeature().get().name().elements();
        scala.collection.immutable.Seq<org.sireum.String> dstNameSeq = dst.get(0).getFeature().get().name().elements();
        // eclipse jdt hack
        // String srcName = src.get(0).getFeature().get().name().elements().toList().last().string();
        // String dstName = dst.get(0).getFeature().get().name().elements().toList().last().string();
        String srcName = ((scala.collection.IterableOnceOps<?, ?, ?>) srcNameSeq).toList().last().toString();
        String dstName = ((scala.collection.IterableOnceOps<?, ?, ?>) dstNameSeq).toList().last().toString();
        name = VisitorUtil.add(path, conn.getName() + "-" + srcName + "_" + dstName);
    // System.out.println(conn.getName());
    }
    final List<String> na = name;
    final List<org.sireum.hamr.ir.Property> properties = conn.getOwnedPropertyAssociations().stream().map(pa -> buildProperty(pa, na)).collect(Collectors.toList());
    if (src.size() != dst.size()) {
        throw new RuntimeException("Incorrect translation!");
    }
    if (src.equals(dst)) {
    // System.out.println(scie.getComponentInstancePath() + " -> " + dcie.getComponentInstancePath());
    }
    if (!src.equals(dst)) {
        return VisitorUtil.toIList(factory.connection(factory.name(na, VisitorUtil.buildPosInfo(conn)), src, dst, kind, isBiDirectional, connectionInstances, properties, VisitorUtil.getUriFragment(connRef)));
    } else if (dst.isEmpty() && src.isEmpty()) {
        // System.out.println(conn.getName());
        return VisitorUtil.iList();
    } else {
        return VisitorUtil.iList();
    }
}