Runtime System Domain

scriptTask("selectAllPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPorts =
             selectComponentPorts {
                // no predicates: select ALL component ports
             } getComponentPorts()
        scriptLogger.info("Selected {0} component ports.", selectedPorts.size())
      }
    }
  }
}

scriptTask("selectAllUnconnectedPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPorts =
             selectComponentPorts {
                unconnected() // select all unconnected component ports
             } getComponentPorts()
        scriptLogger.info("Selected {0} component ports.", selectedPorts.size())
      }
    }
  }
}

scriptTask("selectAllUnconnectedSRAndConnectedModePorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPorts =
             selectComponentPorts {
                // start with logical OR
                or {
                 and { // unconnected sender/receiver ports
                    unconnected()
                    senderReceiver()
                 }
                 and { // connected modeSwitch ports
                    connected()
                    modeSwitch()
                 }
                }
             } getComponentPorts()
        scriptLogger.info("Selected {0} component ports.", selectedPorts.size())
      }
    }
  }
}

scriptTask("selectNotCompletedPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPorts =
             selectComponentPorts {
                // this predicate filters for ports
                // which needs to be connected and/or a data mapping
                notCompleted()
             } getComponentPorts()
        scriptLogger.info("Selected {0} component ports.", selectedPorts.size())
      }
    }
  }
}

scriptTask ("selectComponentPortsUsingOriginContextPredicates", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {

                // we want to use information from the structured extract to select flat extract ports

                def selectedComponentPorts = selectComponentPorts {
                    // use component port related predicates
                    senderReceiver()
                    required()

                    // combine them with origin context related predicates
                    // but remember that we are still selecting flat extract ports here
                    // we only use the origin context ports as additional criteria

                    // we want only ports for which the connection ends at the highest composition level inside the top level composition
                    // of the structured extract
                    hasInnerTopLevelDelegationOriginComponentPort()

                    // and only ports whose origin context has a special name pattern for their composition owner instance
                    originComponentPortComponent(~"Origin.*")
                }.getComponentPorts()

                scriptLogger.info("Selected {0} component ports using their origin context as additional selection criteria.",
                    selectedComponentPorts.size())
            }
        }
    }
}

scriptTask("SelectAllUnmappedSignalInstances", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def signalInstances =
                 selectSignalInstances {
                   unmapped() // select all signal instances which are not yet data mapped
                 } getSignalInstances()
        scriptLogger.info("Selected {0} signal instances.",signalInstances.size())
      }
    }
  }
}

scriptTask("SelectAllUnmappedRxOrTransformedSignalInstances", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def signalInstances =
                 selectSignalInstances {
                   // the signal instances should not be data-mapped yet
                   unmapped()
                   or { // and should either be a rx signal or a transformation signal
                     rx()
                     transformed()
                   }
                 } getSignalInstances()
        scriptLogger.info("Selected {0} signal instances.",signalInstances.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
scriptTask("SelectSignalInstancesUsingAdvancedFilter", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def signalInstances =
                 selectSignalInstances {
                   filterAdvanced { SIAbstractSignalInstance signalInstance ->
                          // implement own custom filter
                          def mdfObject = signalInstance.getMdfObject()
                          // work on directly on autosar model level ...
                          // select signal instance only which has admin data
                          def select = mdfObject.adminData != null
                          select
                   }
                 } getSignalInstances()
        scriptLogger.info("Selected {0} signal instances.",signalInstances.size())
      }
    }
  }
}

scriptTask("SelectAllUnmappedDelPortComElements", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def comElements =
                 selectCommunicationElements {
                   // select all unmapped delegation communication elements
                   delegation()
                   unmapped()
                 } getCommunicationElements()
        scriptLogger.info("Selected {0} communication elements.",comElements.size())
      }
    }
  }
}

scriptTask("SelectComplexFullyExpanded", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def comElements =
                 selectCommunicationElements {
                   // expand all complex communication elements except primitive arrays
                   // and select all communication elements with their leafs
                   // e.g. for a record we select both here, the record and its record elements
                   selectFullyExpandedButPrimitiveArraysAsLeafs()
                 } getCommunicationElements()
        scriptLogger.info("Selected {0} communication elements.",comElements.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.communication.SIDataCommunicationElement
scriptTask("SelectComElementsUsingAdvancedFilter", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def comElements =
             selectCommunicationElements {
               // advanced filter:
               // only select communication elements
               // which represent data elements of a specific data type
               filterAdvanced { SICommunicationElement comElement ->
                   if (comElement instanceof SIDataCommunicationElement) {
                      def mdfDataElement = comElement.getTargetElement().getMdfObject()
                      // check directly on autosar model level
                      return mdfDataElement.type.refTarget.name.equals("myCustomDataType")
                   }
                   false
               }
             } getCommunicationElements()
        scriptLogger.info("Selected {0} communication elements.",comElements.size())
      }
    }
  }
}

scriptTask ("selectComponentTypeByName", DV_PROJECT ){
    code {
        domain.runtimeSystem {
            def selectedComponentTypes = selectComponentTypes {
                name "App1"
            }.getComponentTypes()

            scriptLogger.info("Selected '{0}' component types.", selectedComponentTypes.size())
        }
    }
}

scriptTask ("selectNotInstantiatedComponentTypes", DV_PROJECT ){
    code {
        domain.runtimeSystem {
            def selectedComponentTypes = selectComponentTypes {
                not {
                    instantiated()
                }
            }.getComponentTypes()

            scriptLogger.info("Selected '{0}' component types.", selectedComponentTypes.size())
        }
    }
}

scriptTask ("selectEvents", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def selectedEvents = selectEvents {
                    // select all unmapped events of component 'App1'
                    unmapped()
                    component("App1")
                }.getEvents()

                scriptLogger.info("Selected '{0}' events.", selectedEvents.size())
            }
        }
    }
}

scriptTask ("selectExecutableEntities", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def selectedExecutables = selectExecutableEntities {
                    // select all runnables with symbol 'MySymbol'
                    symbol("MySymbol")
                    runnableEntity()
                }.getExecutableEntities()

                scriptLogger.info("Selected '{0}' executable entities.", selectedExecutables.size())
            }
        }
    }
}

scriptTask("selectPortInterfacesByName", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPortInterfaces =
             selectPortInterfaces {
                // selects all sender receiver application port interfaces with the name 'MyPortInterface'
                senderReceiver()
                application()
                name "MyPortInterface"

             // getPortInterfaces() will filter all port interfaces for the given predicates
             // so in our example we will receive
             // all sender receiver application port interfaces with the short name 'MyPortInterface'
             } getPortInterfaces()
        scriptLogger.info("Selected {0} port interfaces.", selectedPortInterfaces.size())
      }
    }
  }
}

scriptTask("selectPortInterfacesByComponentPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedPortInterfaces =
             selectPortInterfaces {
                // selects the port interface of the port 'pCSPort1' of component 'App1'
                componentPort "App1.pCSPort1"
             } getPortInterfaces()
        scriptLogger.info("Selected {0} port interfaces.", selectedPortInterfaces.size())
      }
    }
  }
}

scriptTask("selectOriginComponentPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def selectedOriginPorts = selectOriginComponentPorts {
            innerTopLevelDelegation()
            provided()
        } getOriginComponentPorts()

        scriptLogger.info("Selected '{0}' origin component ports.", selectedOriginPorts.size())
     }
    }
  }
}

scriptTask("originPortsForFlatExtractPort", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        // first we need to find our flat view port
        // we will use the component port selection for this example
        def componentPort = selectComponentPorts {
            name "pDataSend"
            component "App1"
        } getComponentPorts().iterator().next()

        def selectedOriginPorts = selectOriginComponentPorts {
            ofFlatExtractPort(componentPort)
        } getOriginComponentPorts()

        scriptLogger.info("Selected '{0}' origin component ports for {1}.",
            selectedOriginPorts.size(),
            componentPort.getName())
     }
    }
  }
}

scriptTask("automapAll", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
                 selectComponentPorts {
                    // no predicates: select ALL component ports
                 } autoMap()
        scriptLogger.info("Created {0} mappings.", mappedConnectors.size())
      }
    }
  }
}

scriptTask("automapAllUnconnected", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
             selectComponentPorts {
                 unconnected() // select all unconnected component ports
             } autoMap()
        scriptLogger.info("Created {0} mappings.", mappedConnectors.size())
      }
    }
 }
}

scriptTask("autoMapUnconnectedSRCS", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
                selectComponentPorts {
                   // select all unconnected client/server and unconnected sender/receiver ports
                   unconnected()
                   or {
                     clientServer()
                     senderReceiver()
                   }
                } autoMap()
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("autoMapAdvancedfilter", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
                selectComponentPorts {
                  // select component port by own custom filter predicate
                  filterAdvanced { SIComponentPort port ->
                       "MyUUID".equals(port.getPort().getMdfObject().getUuid2())
                  }
                } autoMap()
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

scriptTask("autoMapUnconnectedToComponentPrototype", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
       def mappedConnectors =
                selectComponentPorts {
                   unconnected() // select all unconnected ports
                 } autoMapTo {
                   selectTargetPorts {
                       component "App1" // and auto-map them to all ports of component "App1"
                   }
                 }
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.connector.SISourceComponentPort
import com.vector.cfg.sysdesc.model.connector.SITargetComponentPort

scriptTask("automapAllUnconnectedAndEvaluateMatches", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
             selectComponentPorts {
               unconnected()
             } autoMapTo {
                evaluateMatches {
                    SISourceComponentPort sourcePort,
                    SITargetComponentPort optionalMatchedTargetPort,
                    List<SITargetComponentPort> potentialTargetPorts ->
                        if (sourcePort.getPortName().equals("MyExceptionalPort")) {
                            // example for excluding a port from auto-mapping by having a close look
                            // sourcePort.getMdfPort()....
                            return null
                        }
                        // default: do not change the auto-matched port
                        [optionalMatchedTargetPort]
                }
             }
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.connector.SISourceComponentPort
import com.vector.cfg.sysdesc.model.connector.SITargetComponentPort

scriptTask("anotherExampleForUsingEvaluateMatches", DV_PROJECT){
   code {
      transaction {
         domain.runtimeSystem {
            def mappedConnectors =
               selectComponentPorts {
               unconnected()
                    } autoMapTo {
                        evaluateMatches {
                            SISourceComponentPort sourcePort,
                            SITargetComponentPort optionalMatchedTargetPort,
                            List<SITargetComponentPort> potentialTargetPorts ->

                            // iterate over potential target ports to find the correct target

                            // like in java you can use a for loop
                            for (SITargetComponentPort targetCP : potentialTargetPorts) {
                                if (targetCP.getPortName().startsWith("MyPort_")) {
                                    return [targetCP]
                                }
                            }

                            // or you can use a stream
                            def myTargets = potentialTargetPorts.findAll {
                                it.getPortName().startsWith("OtherPort_")
                            }
                            return myTargets
                        }
                  }
             scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
         }
       }
    }
 }

import com.vector.cfg.sysdesc.model.connector.SISourceComponentPort
import com.vector.cfg.sysdesc.model.connector.SITargetComponentPort

scriptTask("automap1ToN", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
                 selectComponentPorts {
                   // select single delegation port
                   delegation()
                   name "rDelegationSRPort1"
                 } autoMapTo {
                    selectTargetPorts {
                       // select a collection of target ports (names start with "rSRPort")
                       name ~"rSRPort.*"
                    }
                    evaluateMatches {
                         SISourceComponentPort sourcePort,
                         SITargetComponentPort optionalMatchedTargetPort,
                         List<SITargetComponentPort> potentialTargetPorts ->
                            // return all potentialTargetPorts for 1:n connections, not only the one matched best
                            potentialTargetPorts
                    }
                 }
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

scriptTask("autoMapTwoNonMatchingPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def mappedConnectors =
                 selectComponentPorts {
                   // select a single source component port
                   name "prNVPort1"
                   component "NvApp1"
                 } autoMapTo {
                   selectTargetPorts {
                       // select a single target component port
                       name "rSRPort2"
                       component "App2"
                   }
                   // force the connection even names do not match at all
                   forceConnectionWhen1To1()
                 }
        scriptLogger.info("Created {0} mappings.",mappedConnectors.size())
      }
    }
  }
}

scriptTask("mapUsingOriginContext", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def createdConnections = selectComponentPorts {
            component("App1OriginContextMatch")
            name("A")
        } autoMapTo {
            // this option will not only match the name of the port 'A'
            // but also the delegation ports' names of incomplete connections of the structured extract
            useOriginContextForMatch()
        }

        scriptLogger.info("Created '{0}' connections.", createdConnections.size())
     }
    }
  }
}

scriptTask("connectDiagPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
       def mappedConnectors =
                selectComponentPorts {
                   // activate diagnostic connection mode
                   // this mode shall not be part of a or{...}, and{...} or not{...} closure
                   // hasDiagnosticConnection can be used instead if required, but is very expensive in terms of performance
                   diagnosticConnection()
                   // further predicates can also be specified here if required
                 } autoMapTo {
                   selectTargetPorts {
                       component "App1" // narrow down selection of target ports if necessary
                   }
                 }
        scriptLogger.info("Created {0} mappings.", mappedConnectors.size())
      }
    }
  }
}

scriptTask("connectDiagPortsWithoutNvPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
       def mappedConnectors =
                selectComponentPorts {
                   diagnosticConnection()
                   not {
                       nvData() // exclude nv ports
                   }
                 } autoMapTo {
                 }
        scriptLogger.info("Created {0} mappings. Excluded Nv Ports.", mappedConnectors.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.port.EDiagnosticPortRole

scriptTask("connectDiagPortsIOControl", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
       def mappedConnectors =
                selectComponentPorts {
                   diagnosticConnection()
                   diagnosticPortRole(EDiagnosticPortRole.IO_CONTROL)
                 } autoMap()
        scriptLogger.info("Created {0} mappings for IOControl ports.", mappedConnectors.size())
      }
    }
  }
}

import java.util.Optional

scriptTask ("assemblyConnectionExample", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {

                // enter component and port name of a component port and the component port to connect it to
                // optionally you can add a port interface mapping
                def createdConnector = componentPort("App1", "pDataSend").connectTo("App2", "rSRPort2", Optional.empty())

                scriptLogger.info("Created a connection between '{0}' and '{1}'.",
                createdConnector.getProviderPort().getName(),
                createdConnector.getRequesterPort().getName())
            }
        }
    }
}

import java.util.Optional

scriptTask ("delegationConnectionExample", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                // to select a delegation port the name of the ECU Composition is used as component name
                def createdConnector = componentPort("COMPOSITIONTYPE", "rDelegationSRPort1").connectTo("App2", "rSRPort2", Optional.empty())

                // the provided and required port getter work also for delegation connections
                // you can find more info in the java doc of IConnector
                scriptLogger.info("Created a connection between '{0}' and '{1}'.",
                createdConnector.getProviderPort().getName(),
                createdConnector.getRequesterPort().getName())
            }
        }
    }
}

import java.util.Optional

scriptTask ("delegationConnectionExample", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def portInterfaceMappingPath = "/ComponentTypes/DataTypeMappingSets/PortInterfaceMappingSet1/Mapping1"

                // to add a port interface mapping to the connection, use an optional with the AUTOSAR path to the port interface mapping
                def createdConnector = componentPort("COMPOSITIONTYPE", "pDelegationSRPort2").connectTo("App1", "pSRPort1", Optional.of(portInterfaceMappingPath))

                scriptLogger.info("Created a connection between '{0}' and '{1}'.",
                createdConnector.getProviderPort().getName(),
                createdConnector.getRequesterPort().getName())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.connector.SIConnector
import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("UseSimpleAPIToCreateMultipleConnections", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {
                // in this example we know for each port the target port (for example stored in some external file)
                // and we know that the names of source and target ports do not always match
                // so we use the simple API instead of the auto mapping
                List<String> sourcePortNames = ["App1.pDataSend",
                        "App1.pNvPort1",
                        "App1.pCSPort1"]
                List<String> targetPortNames = ["ECU Composition.pDelegationSRPort2",
                        "App2.rNVPort1",
                        "App3.rOtherPort1CS"]

                // retrieve the component ports for the names
                List<SIComponentPort> sourcePorts = new ArrayList<SIComponentPort>(selectComponentPorts {
                    componentPortNames(sourcePortNames)
                }.getComponentPorts())

                // since our used predicate does not guarantee any order, we have to sort our ports to assure they are in correct order
                // because the connections below will be created matching index of source and target ports
                sourcePorts.sort{a,b -> sourcePortNames.indexOf(a.getName()) <=> sourcePortNames.indexOf(b.getName())}

                // do the same for the target ports
                List<SIComponentPort> targetPorts = new ArrayList<SIComponentPort>(selectComponentPorts {
                    componentPortNames(targetPortNames)
                }.getComponentPorts())

                targetPorts.sort{a,b -> targetPortNames.indexOf(a.getName()) <=> targetPortNames.indexOf(b.getName())}

                // we just want to make sure that the ports are connected
                // so we use assureConnectedTo(...) instead of connectTo(...)
                // in other words we do not care, which ports are already connected
                List<SIConnector> newConnectors = componentPorts(sourcePorts).assureConnectedTo(targetPorts)

                // finally do some reporting for the port pairs that were unconnected
                for (SIConnector connector in newConnectors) {
                    scriptLogger.info("Connected {0} to {1}.",
                            connector.getProviderPort().getName(),
                            connector.getRequesterPort().getName())
                }
            }
        }
    }
}

import com.vector.cfg.dom.runtimesys.pai.api.IUnmappedPortsResult

scriptTask("unmapComponentPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def unmappedPorts =
                selectComponentPorts {
                  // select the component ports to be unmapped
                  connected()
                  componentPortName("App1.pDataSend")
                } unmap()

        // the simple 'unmap()' removes all connectors connecting the selected component ports to any other ports

        // now print info of for the component ports that were unmapped from each other
        // the data structure is a pair representing the source and the target port which were unmapped
        for (final IUnmappedPortsResult unmappedPortPair : unmappedPorts) {
            scriptLogger.info("Removed connector between {0} -> {1}.",
                    unmappedPortPair.getSourcePort().getName(),
                    unmappedPortPair.getTargetPort().getName())
        }
      }
    }
  }
}

import com.vector.cfg.dom.runtimesys.pai.api.IUnmappedPortsResult
import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("unmapComponentPorts", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def unmappedPorts =
                selectComponentPorts {
                  // select the component ports to be unmapped
                  connected()
                  componentPortName("App1OriginContextMatch.CompletedOriginPortTest")
                } unmapFrom {
                  // the connected (or target) ports can be filtered in this closure
                  selectTargetPorts {
                    componentPortNames(["App1.ConnectedToCompletedOriginTest",
                        "App1_1.ConnectedToCompletedOriginTest"])
                  }

                  // additionally the target matches to be unmapped can be evaluated
                  // the 'targetPorts' below are all ports connected to the 'sourcePort' considering the 'selectTargetPorts' call above
                  evaluateMatches { SIComponentPort sourcePort, List<SIComponentPort> targetPorts ->
                    // in our example we want to unmap the source ports only from ports of the component 'App1_1'
                    targetPorts.each {
                        if (it.getComponent().getName().equals("App1_1")) {
                            return [it]
                        }
                    }
                  }
                }

        // print info for newly unmapped ports
        for (final IUnmappedPortsResult unmappedPortPair : unmappedPorts) {
            scriptLogger.info("Removed connector between {0} -> {1}.",
                    unmappedPortPair.getSourcePort().getName(),
                    unmappedPortPair.getTargetPort().getName())
        }
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("terminatePort", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        // the the statements below will return us a collection with all component ports which will be terminated
        def terminatedPorts =
             selectCommunicationElements {
                // also for the communication elements there are predicates to filter for terminated owner ports
                ownerPortNotTerminated()
                port("pSRPort1")

             // this call will terminate the component port owner of each selected communication element
             } terminateOwnerPorts()

        // if multiple communication elements has the same component port owner
        // the component port will be terminated and returned only once
        for (final SIComponentPort terminatedPort : terminatedPorts) {
            scriptLogger.info("Terminated component port '{0}'.", terminatedPort.getName())
        }
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("removePortTerminator", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        // the statements below will return us a collection with all component ports for which a port terminator was removed
        def removedPortTerminators =
             selectCommunicationElements {
                component("App1_1")
                port("pSRPort1")

             // if a port is not terminated it will be skipped
             } removePortTerminatorsForOwnerPorts()

        for (final SIComponentPort componentPort : removedPortTerminators) {
            scriptLogger.info("Removed port terminator of component port '{0}'.", componentPort.getName())
        }
      }
    }
  }
}

scriptTask("autoDatamapAllUnmappedSignalInstances", DV_PROJECT){
    code {
        transaction {
            domain.runtimeSystem {
                def dataMappings =
                             selectSignalInstances {
                               unmapped()
                             } autoMap()
                scriptLogger.info("Created {0} data mappings.",dataMappings.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement

scriptTask("autoDatamapAllUnmappedSignalInstancesAndEvaluate", DV_PROJECT){
    code {
        transaction {
            domain.runtimeSystem {
                def dataMappings =
                     selectSignalInstances {
                       unmapped()
                     } autoMapTo {
                          selectTargetCommunicationElements {
                               unmapped()
                          }
                          evaluateMatches {
                             SIAbstractSignalInstance signal,
                             SICommunicationElement optionalMatchedComElement,
                             List<SICommunicationElement>  potentialComElements ->
                                  // evaluate
                                  optionalMatchedComElement
                          }
                     }
                scriptLogger.info("Created {0} data mappings.",dataMappings.size())
            }
        }
    }
}

 import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
 import com.vector.cfg.sysdesc.model.communication.SICommunicationElement

scriptTask("autoDatamapAllSignalInstancesAndDoNotExpandNestedArrayElements", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
           selectSignalInstances {
           } autoMapTo {
              // do not expand nested array elements
              expandNestedArraysOfPrimitive false
              evaluateMatches {
               SIAbstractSignalInstance signal,
               SICommunicationElement optionalMatchedComElement,
               List<SICommunicationElement>  potentialComElements ->
                 // perform manual mapping to a signal group
                 if (signal.getName().equals("elemB_c255f5e38fd8b21d")) {
                  for (final SICommunicationElement comElement : potentialComElements) {
                    if (comElement.getFullyQualifiedName().equals("App2.rSRPort1.Element_2")) {
                      return comElement
                    }
                  }
                }
                // now check: for the group signal the the record element representing an array is not expanded
                if (signal.getName().equals("fieldA_f1d3783e235e88d3")) {
                  // group signal
                  for (final SICommunicationElement comElement : potentialComElements) {
                    if (comElement.getFullyQualifiedName().equals("App2.rSRPort1.Element_2.RecordElement")) {
                      // do some direct mapping here
                    }
                  }
                }
                optionalMatchedComElement
              }
           }
        scriptLogger.info("Created {0} data mappings.",dataMappings.size())
      }
    }
  }
}

 import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
 import com.vector.cfg.sysdesc.model.communication.SICommunicationElement

scriptTask("autoDatamapAllSignalInstancesAndDoExpandSpecificNestedArrayElement", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
           selectSignalInstances {
           } autoMapTo {
              // do not expand nested array elements
              expandNestedArraysOfPrimitive false
              expandNestedArraysOfPrimitive( "App2.rSRPort1.Element_2.RecordElement",true)
              evaluateMatches {
               SIAbstractSignalInstance signal,
               SICommunicationElement optionalMatchedComElement,
               List<SICommunicationElement>  potentialComElements ->
                 // perform manual mapping to a signal group
                 if (signal.getName().equals("elemB_c255f5e38fd8b21d")) {
                  for (final SICommunicationElement comElement : potentialComElements) {
                    if (comElement.getFullyQualifiedName().equals("App2.rSRPort1.Element_2")) {
                      return comElement
                    }
                  }
                }
                // now check: for the group signal the the record element representing an array is expanded:
                // the single array elements can be mapped
                if (signal.getName().equals("fieldA_f1d3783e235e88d3")) {
                  // group signal
                  for (final SICommunicationElement comElement : potentialComElements) {
                    if (comElement.getFullyQualifiedName().equals("App2.rSRPort1.Element_2.RecordElement[0]")) {
                      // do some direct mapping to array element here
                    }
                  }
                }
                optionalMatchedComElement
              }
           }
        scriptLogger.info("Created {0} data mappings.",dataMappings.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.ECompatibility
import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.datamapping.SIDataMapping

scriptTask("evaluateCommunicationElementsByCompatibility", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we want to accept full matches for data mapping
                // and apply some custom rules for non-full matches

                List<SIDataMapping> createdMappings = selectSignalInstances {
                    unmapped()
                } autoMapTo {
                    evaluateMatchesWithCompatibility {
                        SIAbstractSignalInstance signal,
                        SICommunicationElement optionalMatchedCommunicationElement,
                        ECompatibility compatibility,
                        List<SICommunicationElement> potentialComElements ->

                        if (compatibility == ECompatibility.FULL) {
                            return optionalMatchedCommunicationElement
                        }
                        // for non-full matches we return the first potential match if present
                        if (potentialComElements.size() > 0) {
                            return potentialComElements.get(0)
                        }
                        return null
                    }
                }

                scriptLogger.info("Created {0} data mappings.", createdMappings.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.communication.ECompatibility
import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.datamapping.SIDataMapping

scriptTask("confirmMappingToComElementByCompatibility", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we want only to accept data mappings with a full match
                // and report all other

                List<SIDataMapping> createdMappings = selectSignalInstances {
                    unmapped()
                } autoMapTo {
                    confirmByCompatibility {
                        SIAbstractSignalInstance signal,
                        SICommunicationElement optionalMatchedCommunicationElement,
                        ECompatibility compatibility ->

                        if (compatibility == ECompatibility.FULL) {
                             // accept full match
                            return true
                        }

                        if (optionalMatchedCommunicationElement != null) {
                            // report non-full matches
                            scriptLogger.info("Compatibility {0} between signal {1} and communication element {2}.",
                                compatibility,
                                signal.getName(),
                                optionalMatchedCommunicationElement.getFullyQualifiedName())
                        } else {
                            // report signals for which the auto mapper could not find a match
                            scriptLogger.info("No match for signal {0}.",
                                signal.getName())
                        }
                        return false
                    }
                }

                scriptLogger.info("Created {0} data mappings.", createdMappings.size())
            }
        }
    }
}

scriptTask("autoDatamapAllUnmappedSRDelPortComElements", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
                 selectCommunicationElements {
                   // select all unmapped sender/receiver delegation ports
                   delegation()
                   unmapped()
                   senderReceiver()
                 } autoMap()
        scriptLogger.info("Created {0} data mappings.",dataMappings.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement

scriptTask("autoDatamapAllUnmappedComElementsAndEvaluate", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
             selectCommunicationElements {
               unmapped() // only unmapped communication elements
             } autoMapTo {
                  selectTargetSignalInstances {
                       // only map to unmapped rx signal instances
                       unmapped()
                       rx()
                  }

                  // we selected only the root communication elements, but for performing the data mapping the complex data elements are expanded
                  // this is a behavior which you can also notice in the data mapping assistant in the GUI
                  // that means the evaluateMatches method will also offer child communication elements and the corresponding matched group signals
                  evaluateMatches {
                     SICommunicationElement  communicationElement,
                     SIAbstractSignalInstance optionalMatchedSignalInstance,
                     List<SIAbstractSignalInstance>  potentialSignalinstances ->
                          // evaluate the match here
                          if (optionalMatchedSignalInstance != null) {
                                def mdfSystemSignal = optionalMatchedSignalInstance.getMdfObject()
                                // check more specific ...
                          }
                          optionalMatchedSignalInstance
                  }
             }
        scriptLogger.info("Created {0} data mappings.", dataMappings.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.communication.instance.SISignalGroupInstance

scriptTask("autoDatamapDoNotExpandNestedArrayElements", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
         selectCommunicationElements {
         } autoMapTo {
             expandNestedArraysOfPrimitive false // do not expand nested arrays of primitive
             evaluateMatches {
                 SICommunicationElement  communicationElement,
                 SIAbstractSignalInstance optionalMatchedSignalInstance,
                 List<SIAbstractSignalInstance>  potentialSignalInstances ->
                    if ("App2.rSRPort1.Element_2".equals(communicationElement.getFullyQualifiedName())) {
                        // manual matching: map to first signal group
                        for (SIAbstractSignalInstance potentialSignal: potentialSignalInstances) {
                            if (potentialSignal instanceof SISignalGroupInstance) {
                                return potentialSignal
                            }
                        }
                    }
                    if ("App2.rSRPort1.Element_2.RecordElement".equals(communicationElement.getFullyQualifiedName())) {
                        // now the RecordElement which represents an array is directly offered to map
                        // ....
                    }
                    optionalMatchedSignalInstance
              }
         }
        scriptLogger.info("Created {0} data mappings.",dataMappings.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.communication.instance.SISignalGroupInstance

scriptTask("autoDatamapDoExpandSpecificNestedArrayElement", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def dataMappings =
             selectCommunicationElements {
             } autoMapTo {
                 // do not generally expand nested arrays of primitive
                 expandNestedArraysOfPrimitive false
                 // but expand the following specific record element
                 expandNestedArraysOfPrimitive("App2.rSRPort1.Element_2.RecordElement",true)
                 evaluateMatches {
                     SICommunicationElement  communicationElement,
                     SIAbstractSignalInstance optionalMatchedSignalInstance,
                     List<SIAbstractSignalInstance>  potentialSignalInstances ->
                        if ("App2.rSRPort1.Element_2".equals(communicationElement.getFullyQualifiedName())) {
                            // manual matching: map to first signal group
                            for (SIAbstractSignalInstance potentialSignal: potentialSignalInstances) {
                                if (potentialSignal instanceof SISignalGroupInstance) {
                                    return potentialSignal
                                }
                            }
                        }
                        if ("App2.rSRPort1.Element_2.RecordElement[0]".equals(communicationElement.getFullyQualifiedName())) {
                            // the RecordElement (representing an array of primitive)  is expanded to map the single array elements
                            // ....
                        }
                        optionalMatchedSignalInstance
                  }
             }
        scriptLogger.info("Created {0} data mappings.",dataMappings.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.ECompatibility
import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.datamapping.SIDataMapping

scriptTask("evaluateSignalsByCompatibility", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we want to accept full matches for data mapping
                // and apply some custom rules for non-full matches

                List<SIDataMapping> createdMappings = selectCommunicationElements {
                    unmapped()
                    senderReceiver()
                } autoMapTo {
                    evaluateMatchesWithCompatibility {
                        SICommunicationElement communicationElement,
                        SIAbstractSignalInstance optionalMatchedSignal,
                        ECompatibility compatibility,
                        List<SIAbstractSignalInstance> potentialSignals ->

                        if (compatibility == ECompatibility.FULL) {
                            return optionalMatchedSignal
                        }
                        // for non-full matches we return the first potential match if present
                        if (potentialSignals.size() > 0) {
                            return potentialSignals.get(0)
                        }
                        return null
                    }
                }

                scriptLogger.info("Created {0} data mappings.", createdMappings.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.communication.ECompatibility
import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance
import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.datamapping.SIDataMapping

scriptTask("confirmMappingToSignalByCompatibility", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we want only to accept data mappings with a full match
                // and report all other


                List<SIDataMapping> createdMappings = selectCommunicationElements {
                    unmapped()
                    senderReceiver()
                } autoMapTo {
                    confirmByCompatibility {
                        SICommunicationElement communicationElement,
                        SIAbstractSignalInstance optionalMatchedSignal,
                        ECompatibility compatibility ->

                        if (compatibility == ECompatibility.FULL) {
                            return true
                        }
                        if (optionalMatchedSignal != null) {
                            // report non-full matches
                            scriptLogger.info("Compatibility {0} between signal {1} and communication element {2}.",
                                compatibility,
                                optionalMatchedSignal.getName(),
                                communicationElement.getFullyQualifiedName())
                        } else {
                            // report signals for which the auto mapper could not find a match
                            scriptLogger.info("No match for communication element {0}.",
                                communicationElement.getName())
                        }
                        return false
                    }
                }

                scriptLogger.info("Created {0} data mappings.", createdMappings.size())
            }
        }
    }
}

scriptTask ("createSimpleMapping", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                // specify path to the system signal
                def signalPath = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/Element_1_b16df82332bcf915"

                // enter the fully qualified communication element name
                // that means ComponentName.PortName.DataElementName
                def communicationElementName = "App1.pDataSend.Element"

                def createdMapping = communicationElement(communicationElementName).mapTo(signalPath)

                scriptLogger.info("Mapped '{0}' to '{1}'.",
                createdMapping.getCommunicationElement().getFullyQualifiedName(),
                createdMapping.getSystemSignal().getAutosarPath())
            }
        }
    }
}

scriptTask ("mapDelegationPort", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def signalPath = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/Element_1_b16df82332bcf915"

                // for delegation ports use 'ECU Composition' instead of the component name
                def communicationElementName = "ECU Composition.pDelegationSRPort2.Element"

                def createdMapping = communicationElement(communicationElementName).mapTo(signalPath)

                scriptLogger.info("Mapped '{0}' to '{1}'.",
                createdMapping.getCommunicationElement().getFullyQualifiedName(),
                createdMapping.getSystemSignal().getAutosarPath())
            }
        }
    }
}

scriptTask ("createClientServerMapping", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def callSignalPath = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/rSRPort2_d4aecc362f1feef3"
                def returnSignalPath = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/pSRPort3_2264a06bc04fc81d"

                // if an operation communication element is selected, a client server to signal mapping will be created
                // the assignment of call and return signal role is depending on the direction of the signal
                def communicationElementName = "ECU Composition.pDelegationCSPort1.Operation"

                def createdMapping = communicationElement(communicationElementName).mapTo(callSignalPath, returnSignalPath)

                scriptLogger.info("Mapped '{0}' to '{1}' as call signal and '{2}' as return signal.",
                createdMapping.getCommunicationElement().getFullyQualifiedName(),
                createdMapping.getSystemSignal().getAutosarPath(),
                createdMapping.getReturnSystemSignal().getAutosarPath())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.datamapping.SISenderReceiverDataMapping

scriptTask ("mapRecordToSignalGroup", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                // specify the path to the signal group
                def signalGroup = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNAL_GROUPS/Element_2_de8db6949370c6b4"

                // specify the paths to the group signals of the signal group
                def groupSignal1 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay1_48523fe229ba8c99"
                def groupSignal2 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay2_071a3305d39fcca4"
                def groupSignal3 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay3_84eba37e401eacd1"

                // the name of the root element
                def record = "ECU Composition.pDelegationSRPort1.Element_2"

                // the names of the child elements
                def recordElement1 = "ECU Composition.pDelegationSRPort1.Element_2.RecordElement"
                def recordElement2 = "ECU Composition.pDelegationSRPort1.Element_2.RecordElement_1"
                def recordElement3 = "ECU Composition.pDelegationSRPort1.Element_2.RecordElement_2"

                // create the mapping, first argument should be the root element, followed by the leaf elements for the child mappings
                // for the signals, first argument should be the signal group, followed by the group signals

                // the mapping will be done using the given order
                // e.g. the first element (record) will be mapped to the signal group (signalGroup),
                // the last record element (recordElement3) will be mapped to the last group signal (groupSignal3)
                def createdMapping = communicationElement(record, recordElement1, recordElement2, recordElement3)
                    .mapTo(signalGroup, groupSignal1, groupSignal2, groupSignal3)

                scriptLogger.info("Mapped '{0}' to '{1}'.",
                createdMapping.getCommunicationElement().getFullyQualifiedName(),
                createdMapping.getSystemSignal().getAutosarPath())

                // print info for the child mappings
                for (final SISenderReceiverDataMapping childMapping : createdMapping.getChildDataMapping()) {
                    scriptLogger.info("Mapped '{0}' to '{1}'.",
                    childMapping.getCommunicationElement().getFullyQualifiedName(),
                    childMapping.getSystemSignal().getAutosarPath())
                }
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.datamapping.SISenderReceiverDataMapping

scriptTask ("mapArrayToSignalGroup", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                // specify the path to the signal group
                def signalGroup = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNAL_GROUPS/Element_2_de8db6949370c6b4"

                // specify the paths to the group signals of the signal group
                def groupSignal1 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay1_48523fe229ba8c99"
                def groupSignal2 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay2_071a3305d39fcca4"
                def groupSignal3 = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNALS/ay3_84eba37e401eacd1"

                // the name of the root element
                def array = "ECU Composition.pDelegationSRPort2.Element_1"

                // select the element of the array using the position index of the element
                def arrayElement1 = "ECU Composition.pDelegationSRPort2.Element_1[0]"
                def arrayElement2 = "ECU Composition.pDelegationSRPort2.Element_1[1]"
                def arrayElement3 = "ECU Composition.pDelegationSRPort2.Element_1[2]"

                def createdMapping = communicationElement(array, arrayElement1, arrayElement2, arrayElement3)
                    .mapTo(signalGroup, groupSignal1, groupSignal2, groupSignal3)

                scriptLogger.info("Mapped '{0}' to '{1}'.",
                createdMapping.getCommunicationElement().getFullyQualifiedName(),
                createdMapping.getSystemSignal().getAutosarPath())

                // print info for the child mappings
                for (final SISenderReceiverDataMapping childMapping : createdMapping.getChildDataMapping()) {
                    scriptLogger.info("Mapped '{0}' to '{1}'.",
                    childMapping.getCommunicationElement().getFullyQualifiedName(),
                    childMapping.getSystemSignal().getAutosarPath())
                }
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.datamapping.SISenderReceiverDataMapping

scriptTask("completeComplexDataMapping", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we want to map a record to a system signal group
                // we will map only the roots
                // a comfort function will try to find matches in record elements and group signals via naming

                String recordName = "ECU Composition.pDelegationSRPort1.Element_2"
                String signalGroupPath = "/VectorAutosarExplorerGeneratedObjects/SYSTEM_SIGNAL_GROUPS/Element_2_de8db6949370c6b4"

                SISenderReceiverDataMapping createdDataMapping = communicationElement(recordName).mapTo(signalGroupPath)

                scriptLogger.info("Mapped {0} -> {1}.",
                createdDataMapping.getCommunicationElement().getFullyQualifiedName(),
                createdDataMapping.getSystemSignal().getName())

                // we want also to print info for the child mappings
                for (SISenderReceiverDataMapping childMapping in createdDataMapping.getLeafDataMappings()) {
                    scriptLogger.info("Mapped {0} -> {1}.",
                    childMapping.getCommunicationElement().getFullyQualifiedName(),
                    childMapping.getSystemSignal().getName())
                }
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.communication.SICommunicationElement
import com.vector.cfg.sysdesc.model.datamapping.SIDataMapping
import com.vector.cfg.sysdesc.model.datamapping.SIClientServerToSignalDataMapping
import com.vector.cfg.sysdesc.model.communication.instance.SIAbstractSignalInstance

scriptTask("UseSimpleAPIToCreateMultipleDataMappings", DV_PROJECT) {
    code {
        transaction {
            domain.runtimeSystem {

                // in this example we know for each communication element the name of the system signal to map it to
                // (for example stored in some external file)
                // so we use the simple API instead of the auto mapping

                List<String> comElementNames =
                    ["ECU Composition.TriggerDataMappingZeroLengthSignal.SomeTrigger",
                    // com element below for client server to signal mapping
                    "App1_1.pCSPort1.Operation",
                    "App2.rSRPort1.Element",
                    // com elements below are a record and its record elements
                    "App2.rSRPort1.Element_2",
                    "App2.rSRPort1.Element_2.RecordElement",
                    "App2.rSRPort1.Element_2.RecordElement_2"]
                List<String> signalNames =
                    ["TriggerDataMappingZeroLengthSignal_896bde67e5a0f5b4",
                    // the two signals below are used for a client server to signal mapping
                    // one call and one return signal
                    "rSRPort2_d4aecc362f1feef3", "pSRPort3_2264a06bc04fc81d",
                    "RElement_1_c07c9ba68bc545ba",
                    // com elements below is a signal group and its group signals
                    "elemB_c255f5e38fd8b21d",
                    "fieldA_f1d3783e235e88d3",
                    "fieldB_344fdc16e87cfdaa"]

                // we use the communication element selection to retrieve the communication elements
                // for the client server to signal mapping the selection will find two com elements for the one name
                // one for the call direction and one for the return direction
                List<SICommunicationElement> comElements = selectCommunicationElements {
                    fullyQualifiedNames(comElementNames)
                    // we need to select also unmapped record elements, so use fully expanded selection
                    // another way would be to select only the root
                    // and then access the leafs e.g. via IDataCommunicationElement.getLeafsFullExpandedExceptPrimitiveArrays()
                    selectFullyExpanded()
                }.getCommunicationElements()

                // since our used predicate does not guarantee any order, we have to sort our communication elements to assure they are in correct order
                comElements.sort{a,b -> comElementNames.indexOf(a.getFullyQualifiedName()) <=> comElementNames.indexOf(b.getFullyQualifiedName())}

              // now select and sort the signal instances
              List<SIAbstractSignalInstance> signals = new ArrayList<SIAbstractSignalInstance>(selectSignalInstances {
                  names(signalNames)
              }.getSignalInstances())

              signals.sort{a,b -> signalNames.indexOf(a.getName()) <=> signalNames.indexOf(b.getName())}

              // map communication elements via index to the system signals
              // for complex mappings the children need to be inserted directly after the parent

              // for client server mappings call and return elements right after each other
              // call first or return first does not matter

              // mapTo(...) would fail if one of the mappings does already exist
              // but in this example we just want to make sure that the mapping exist, if not assureMappedTo(...) will create it, if it does exist it will do nothing
              List<SIDataMapping> dataMappings = communicationElements(comElements).assureMappedTo(signals)

              // finally do some reporting for the pairs that were previously not mapped to each other
              for (SIDataMapping dataMapping in dataMappings) {
                  scriptLogger.info("Mapped {0} to {1}.",
                          dataMapping.getCommunicationElement().getFullyQualifiedName(),
                          dataMapping.getSystemSignal().getName())

                  if (dataMapping instanceof SIClientServerToSignalDataMapping) {
                      scriptLogger.info("Return signal is {0}.",
                              ((SIClientServerToSignalDataMapping) dataMapping).getReturnSystemSignal().getName())
                  }
              }
          }
      }
  }
            }

import com.vector.cfg.dom.runtimesys.pai.api.IUnmappedComElementAndSignalResult

scriptTask("UnmapCommunicationElements", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // we want to remove all data mappings of delegation ports in this example
        def result = selectCommunicationElements {
                  mapped()
                  delegation()
                } unmap()


        // now print a detailed info for all removed data mappings
        // we want also detailed info for client server to signal mappings and sender receiver to signal group mappings
        scriptLogger.info("Removed {0} (root) mappings.", result.size())

        for (IUnmappedComElementAndSignalResult unmappedResult : result) {
            scriptLogger.info("{0} -> {1}",
                    unmappedResult.getCommunicationElement().getFullyQualifiedName(),
                    unmappedResult.getSignalInstance().getName())

            // additional info for return signal mapping
            if (unmappedResult.getReturnSignalCommunicationElement() != null) {
                scriptLogger.info("{0} -> {1}",
                        unmappedResult.getReturnSignalCommunicationElement().getFullyQualifiedName(),
                        unmappedResult.getReturnSignalInstance().getName())
            }

            //  additional info for mapped record and array elements
            if (!unmappedResult.getChildCommunicationElements().isEmpty()) {

                for (int i = 0; i < unmappedResult.getChildCommunicationElements().size(); i++) {
                    scriptLogger.info("{0} -> {1}",
                            unmappedResult.getChildCommunicationElements().get(i).getFullyQualifiedName(),
                            unmappedResult.getGroupSignalInstances().get(i).getName())
                }
            }
        }
      }
    }
  }
}

scriptTask("UnmapCommunicationElementsAdvanced", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // we want to remove only data mappings for delegation ports to signals of a special frame
        def result = selectCommunicationElements {
                  mapped()
                  delegation()
                } unmapFrom {
                    // we have already filtered the communication elements
                    // in this closure we can now additionally filter also for the signals of the data mapping to be removed
                    selectTargetSignalInstances {
                        frame("MyFrame")
                    }
                }


        // see the simple example above how to print more detailed info
        scriptLogger.info("Removed {0} (root) mappings.", result.size())
      }
    }
  }
}

import com.vector.cfg.dom.runtimesys.pai.api.IUnmappedComElementAndSignalResult

scriptTask("UnmapSignalInstances", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // we want to remove all data mappings of all mapped tx signals in this example
        def result = selectSignalInstances {
                  mapped()
                  tx()
                } unmap()


        // now print a detailed info for all removed data mappings
        // we want also detailed info for client server to signal mappings and sender receiver to signal group mappings
        scriptLogger.info("Removed {0} (root) mappings.", result.size())

        for (IUnmappedComElementAndSignalResult unmappedResult : result) {
            scriptLogger.info("{0} -> {1}",
                    unmappedResult.getCommunicationElement().getFullyQualifiedName(),
                    unmappedResult.getSignalInstance().getName())

            // additional info for return signal mapping
            if (unmappedResult.getReturnSignalCommunicationElement() != null) {
                scriptLogger.info("{0} -> {1}",
                        unmappedResult.getReturnSignalCommunicationElement().getFullyQualifiedName(),
                        unmappedResult.getReturnSignalInstance().getName())
            }

            //  additional info for mapped record and array elements
            if (!unmappedResult.getChildCommunicationElements().isEmpty()) {

                for (int i = 0; i < unmappedResult.getChildCommunicationElements().size(); i++) {
                    scriptLogger.info("{0} -> {1}",
                            unmappedResult.getChildCommunicationElements().get(i).getFullyQualifiedName(),
                            unmappedResult.getGroupSignalInstances().get(i).getName())
                }
            }
        }
      }
    }
  }
}

scriptTask("UnmapSignalInstancesAdvanced", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // we want to remove only data mappings for transformed signals which are mapped to communication elements of component 'App1'
        def result = selectSignalInstances {
                  mapped()
                  transformed()
                } unmapFrom {
                    // we have already filtered the signal instances
                    // in this closure we can now additionally filter also for communication elements of the data mapping to be removed
                    selectTargetCommunicationElements {
                        component("App1")
                    }
                }


        // see the simple example above how to print more detailed info
        scriptLogger.info("Removed {0} (root) mappings.", result.size())
      }
    }
  }
}

scriptTask ("createComponentPrototypesForNotInstantiatedTypes", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def createdComponents = selectComponentTypes {
                    not {
                        instantiated()
                    }
                }.createPrototype()

                scriptLogger.info("Created '{0}' component prototypes.", createdComponents.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.component.SIComponentType

scriptTask ("specifyNameOfCreatedComponent", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def createdComponents = selectComponentTypes {
                    application()
                }.createPrototypeWith {
                    name {
                        // define the naming of new created prototypes
                        SIComponentType<?> type -> type.getName() + "_postfix"
                    }
                }

                scriptLogger.info("Created '{0}' component prototypes.", createdComponents.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.component.SIComponentType

scriptTask ("specifyNameOfCreatedComponent", DV_PROJECT ){
    code {
        transaction {
            domain.runtimeSystem {
                def createdComponents = selectComponentTypes {
                    name ~"App.*"
                }.createPrototypeWith {
                    name {
                        // you can still define a naming pattern
                        SIComponentType<?> type -> type.getName() + "_CP"
                    }

                    // and at the same time define how many prototypes should be created for each component type
                    count(3)
                }

                scriptLogger.info("Created '{0}' component prototypes.", createdComponents.size())
            }
        }
    }
}

import com.vector.cfg.sysdesc.model.communication.EDirection

scriptTask("createDelegationPortSimple", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def createdComponentPorts =
             selectPortInterfaces {
                // select all client server application port interfaces of component 'App3'
                componentType "App3"
                clientServer()
                application()
             } createPrototype {
                // EDirection.Tx to create a PPort and EDirection.Rx to create a RPort
                direction(EDirection.Tx)
                // if no name is specified, the name of the port interface will be taken for the port
               }
        scriptLogger.info("Created {0} delegation ports.", createdComponentPorts.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.EDirection
import com.vector.cfg.sysdesc.model.port.SIPortInterface

scriptTask("createDelegationPortCustomized", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {
        def createdComponentPorts =
             selectPortInterfaces {
                // select the port interface of 'App1.ppFirst' and the port interface named 'Second'
                or {
                    componentPort "App1.ppFirst"
                    name "Second"
                }
             } createPrototype {
                name {
                    // specify the naming of the new ports
                    SIPortInterface<?> portInterface -> "pp" + portInterface.getName() + "_new"
                }
                // EDirection.Rx is leading to the creation of required ports
                direction(EDirection.Rx)
                // for each selected port interface two delegation ports will be created
                count(2)
               }
        scriptLogger.info("Created {0} delegation ports.", createdComponentPorts.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("createDelegationPortFromComponentPort", DV_PROJECT){

  // in this example we want to create a delegation port for an existing SWC port

  code {
    transaction {
      domain.runtimeSystem {
        def createdComponentPorts =
             selectComponentPorts {
                 component "App3"
                 name "rOtherSR1Port"
             } createDelegationPorts {

                // we can use the selected component port to specify the name of the new port
                // also we could have used the name(Closure) method from examples above and use the port interface for naming
                nameFromComponentPort {
                    // specify the naming of the new ports
                    SIComponentPort componentPort -> componentPort.getPortName() + "_new"
                }
                // since we have selected a component port previously, we can now use the direction of it
                // of course it is also possible to use direction(EDirection) here as in the examples above
                useDefaultDirection()
               }
        scriptLogger.info("Created {0} delegation ports.", createdComponentPorts.size())
      }
    }
  }
}

import com.vector.cfg.sysdesc.model.communication.EDirection

scriptTask("createPortFromOriginContext", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // in this example we create a delegation port which is missing
        // the port interface for our new port is provided by an origin context port

        def selectedOriginPorts
        def createdDelegationPorts = selectOriginComponentPorts {
            provided()
            name "OriginContext"

            // remember the selected ports to print better info later
            selectedOriginPorts = getSelectedOriginComponentPorts()

        }.createFlatExtractDelegationPorts {
            // this call retrieves the port interfaces of the selected origin component ports
            // and creates for each origin component port a delegation port

            // specify the name and direction of the new port
            name {
                // optionally you could use the port interface as help for specifying the name here
                // IPortInterface portInterfaceOfOriginPort -> ...
                "PortWithInterfaceOfOriginContext"
            }
            direction(EDirection.Tx)
        }

        for (int i = 0; i < selectedOriginPorts.size(); i++) {
            scriptLogger.info("Created new delegation port {0} for origin port {1}.",
                createdDelegationPorts.get(i).getName(),
                selectedOriginPorts.get(i).getName())
        }
     }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.origin.SIOriginComponentPort

scriptTask("createPortFromOriginContextUsingPort", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        // in this example we create a delegation port which is missing
        // the port interface for our new port is provided by an origin context port
        // and we use the original port for naming and direction this time

        def selectedOriginPorts
        def createdDelegationPorts = selectOriginComponentPorts {
            provided()
            name "OriginContext"

            // remember the selected ports to print better info later
            selectedOriginPorts = getSelectedOriginComponentPorts()

        }.createFlatExtractDelegationPorts {

            // specify the name and direction of the new port
            nameFromOriginPort {  SIOriginComponentPort originPort ->
                originPort.getPortName() + "_new"
            }
            // for the origin component port selection we can use the direction of the previously selected origin ports
            useDefaultDirection()
        }

        for (int i = 0; i < selectedOriginPorts.size(); i++) {
            scriptLogger.info("Created new delegation port {0} for origin port {1}.",
                createdDelegationPorts.get(i).getName(),
                selectedOriginPorts.get(i).getName())
        }
     }
    }
  }
}

import com.vector.cfg.sysdesc.model.component.origin.SIOriginComponentPort
import com.vector.cfg.sysdesc.model.connector.SIConnector
import com.vector.cfg.sysdesc.model.component.SIComponentPort

scriptTask("createAndConnectDelegationPort", DV_PROJECT){
  code {
    transaction {
      domain.runtimeSystem {

        List<SIComponentPort> createdDelegationPorts = selectOriginComponentPorts {
            // select some origin context ports
            provided()
            innerTopLevelDelegation()
        }.createFlatExtractDelegationPorts {

            // create a delegation port for each selected origin port
            nameFromOriginPort {  SIOriginComponentPort originPort ->
                originPort.getPortName()
            }
            useDefaultDirection()
        }

        // now use the new ports to put them into a selection
        // we want to use the auto mapper (using the origin context names) to connect them to inner SWC ports
        List<SIConnector> createdConnections = selectComponentPorts {
            put(createdDelegationPorts)
            // we can still use predicates here, they would be applied only to our new ports which we put into the selection
            // for example we could connect only the provided new delegation ports here using additionally the predicate provided()
        } autoMapTo {
            useOriginContextForMatch()
        }

        // and finally do some reporting
        for (final SIConnector connector : createdConnections) {
            final SIComponentPort pPort = connector.getProviderPort()
            final SIComponentPort rPort = connector.getRequesterPort()

            scriptLogger.info("Created new delegation port {0} and connected it to {1}.",
                pPort.isDelegationPort() ? pPort.getName() : rPort.getName(), // our new created delegation port
                pPort.isDelegationPort() ? rPort.getName() : pPort.getName()) // the connected inner application port
        }

     }
    }
  }
}