End to end flow not instantiated in component with refined features in the flow

[dblouin]

Summary

In the following AADL model, the end to end flow "processing_flow" of system implementation "Test.basic" is not generated in the instance model.

AADL code to reproduce the problem

package issue_flow_instantiation
public
    system Test
    end Test;
    system implementation Test.basic
        subcomponents
            source_comp: device Source_Device;
            test_comp: system Test_System.basic;
            sink_comp: device Sink_Device;
        connections
            conn_1: port source_comp.out_feature -> test_comp.in_feature;
            conn_2: port test_comp.out_feature -> sink_comp.in_feature;
        flows
            processing_flow: end to end flow source_comp.flow_source -> conn_1 -> test_comp.process_flow -> conn_2 -> sink_comp.flow_sink;
        properties
            Classifier_Substitution_Rule => Type_Extension;
    end Test.basic;

    abstract Source_Component
        features
            out_feature: out feature;
        flows
            flow_source: flow source out_feature;
    end Source_Component;

    abstract Sink_Component
        features
            in_feature: in feature;
        flows
            flow_sink: flow sink in_feature;
    end Sink_Component;

    device Source_Device extends Source_Component
        features
            out_feature: refined to out data port;
    end Source_Device;

    device Sink_Device extends Sink_Component
        features
            in_feature: refined to in data port;
    end Sink_Device;

    abstract Test_Component
        features
            in_feature: in feature;
            out_feature: out feature;
        flows
            process_flow: flow path in_feature -> out_feature;
        properties
            Classifier_Substitution_Rule => Type_Extension;
    end Test_Component;

    abstract Test_Subcompo
        features
            in_feature: in feature;
            out_feature: out feature;
        flows
            process_flow: flow path in_feature -> out_feature;
    end Test_Subcompo;

    abstract implementation Test_Component.basic
        subcomponents
            subcompo_1: abstract Test_Subcompo;
            subcompo_2: abstract Test_Subcompo;
        connections
            conn_1: feature in_feature -> subcompo_1.in_feature;
            conn_2: feature subcompo_1.out_feature -> subcompo_2.in_feature;
            conn_3: feature subcompo_2.out_feature -> out_feature;
        flows
            process_flow: flow path in_feature -> conn_1 -> subcompo_1.process_flow -> conn_2 -> subcompo_2.process_flow -> conn_3 -> out_feature;
    end Test_Component.basic;

    system Test_System extends Test_Component
        features
            in_feature: refined to in data port;
            out_feature: refined to out data port;
        flows
            problem_flow: flow path in_feature -> out_feature;
    end Test_System;

    system Test_Subcompo_System extends Test_Subcompo
        features
            in_feature: refined to in data port;
            out_feature: refined to out data port;
    end Test_Subcompo_System;

    system implementation Test_System.basic extends Test_Component.basic
        subcomponents
            subcompo_1: refined to system Test_Subcompo_System;
            subcompo_2: refined to system Test_Subcompo_System;
        connections
            conn_1: refined to port;
            conn_2: refined to port;
            conn_3: refined to port;
        flows
            problem_flow: flow path in_feature -> conn_1 -> subcompo_1.process_flow -> conn_2 -> subcompo_2.process_flow -> conn_3 -> out_feature;
    end Test_System.basic;
end issue_flow_instantiation;

Environment

OSATE 2.4.0.vfinal -- Build id: 2019-03-02

Operating system: Windows 7

Proposed solution

The problem seems to be because the flow involves refined features in a system subcomponent. I looked up class CreateConnectionsSwitch method filterOutgoingConnections. The code below shows a fix that solved the problem for us.

public List<Connection> filterOutgoingConnections(List<Connection> conns, Feature feature, Subcomponent sub) {
    List<Connection> result = new ArrayList<Connection>(conns.size());
    List<Feature> features = feature.getAllFeatureRefinements();
    EList<Subcomponent> subs = sub.getAllSubcomponentRefinements();
    for (Connection conn : conns) {

        // DB: We also need to consider refined features
        final Set<ConnectionEnd> refinedFeatures = new HashSet<ConnectionEnd>();
        final ConnectionEnd conEnd = conn.getAllSource();

        if ( conEnd instanceof Feature ) {
            refinedFeatures.addAll( ( (Feature) conEnd ).getAllFeatureRefinements() );
        }

        for ( final ConnectionEnd refFeat : refinedFeatures ) {
            if ((features.contains( refFeat ) && subs.contains(conn.getAllSourceContext()))
                || (conn.isAllBidirectional() && features.contains(conn.getAllDestination())
                        && subs.contains(conn.getAllDestinationContext()))) {
                result.add(conn);

                break; // DB
            }
        }
    }

    return result;
}

[paolo-crisafulli]

:+1:

[AaronGreenhouse]

Fix seems reasonable. I have checked it in and added a junit test based on the above example.

[lwrage]

The patch is insufficient as it doesn't take bidirectional connections into account.

[lwrage]

Fixed