fun createComposite()

in code/nxt-integration/src/main/kotlin/org/fbme/integration/nxt/refactorings/CompositeCreator.kt [19:75]
49 lines of code
2 McCabe index (conditional complexity)

    fun createComposite(
        fbNetwork: FBNetwork,
        functionBlockDeclarationList: List<FunctionBlockDeclaration>,
        model: SModel,
        factory: IEC61499Factory // TODO add user name for fb name in interface
    ) {
        // maybe sort functionBlockDeclarationList somehow
        val innerFBs = functionBlockDeclarationList.stream().map(Declaration::name).collect(Collectors.toSet())
        val compositeFBNetworkName = java.lang.String.join("_", innerFBs)
        val compositeFBIdentifier = StringIdentifier(compositeFBNetworkName)
        val compositeFB =
            factory.createCompositeFBTypeDeclaration(compositeFBIdentifier) // name in interface (TODO set by user)
        model.addRootNode((compositeFB as PlatformElement).node)
        val compositeFunctionBlockDeclaration =
            factory.createFunctionBlockDeclaration(compositeFBIdentifier) // name in network
        compositeFunctionBlockDeclaration.typeReference.setTarget(compositeFB) // connect declaration in network to real fb in interface
        setDeclarationCoordinates(
            compositeFunctionBlockDeclaration,
            functionBlockDeclarationList
        ) // set network coordinates
        fbNetwork.functionBlocks.add(compositeFunctionBlockDeclaration)
        val eventConnections: List<FBNetworkConnection> = fbNetwork.eventConnections
        val dataConnections: List<FBNetworkConnection> = fbNetwork.dataConnections
        val declarationExtractor = DeclarationExtractor(eventConnections, dataConnections, innerFBs)
        var minX = functionBlockDeclarationList.stream().mapToInt(FunctionBlockDeclaration::x).min().orElse(0)
        for (blockDeclaration in functionBlockDeclarationList) {
            val fbType = blockDeclaration.typeReference.getTarget() ?: continue
            val fbName = blockDeclaration.name
            val shift = createShift(fbName, fbType)
            copyEvents(blockDeclaration, fbType, compositeFB, declarationExtractor, fbName, shift)
            minX = Math.min(minX, blockDeclaration.x + shift.getX(Type.INPUT))
        }

        // setting new associations
        val parameterDeclarationCopyMap = declarationExtractor.parameterDeclarationCopyMap
        setEventAssociations(compositeFB.inputEvents, parameterDeclarationCopyMap)
        setEventAssociations(compositeFB.outputEvents, parameterDeclarationCopyMap)
        rehangExternalConnections(
            declarationExtractor.externalConnectionsInputMap,
            compositeFunctionBlockDeclaration,
            Type.INPUT
        )
        rehangExternalConnections(
            declarationExtractor.externalConnectionsOutputMap,
            compositeFunctionBlockDeclaration,
            Type.OUTPUT
        )

        // TODO think about optimal coordinate shifts
        // int decX = minX > 500 ? minX - 500 : 0;
        val decX = minX
        val decY = functionBlockDeclarationList.stream().mapToInt(FunctionBlockDeclaration::y).min().orElse(0)
        adjustNetworkCoordinates(declarationExtractor, compositeFB, functionBlockDeclarationList, fbNetwork, decX, decY)

        // add connections to external input/output based on existed external connection from inner blocks
        createInnerIOConnections(compositeFB, declarationExtractor.declarationPortPathMap, factory, decX, decY)
    }