Package de.aristaflow.adept2.model.processmodel

Interface ProcessModelFactory

  • All Superinterfaces:
    CommonModelFactory
    public interface ProcessModelFactory
extends CommonModelFactory
    The factory of the processmodel is used to create new objects.
    The factory methods require all properties which belong directly to an object. Since there are no cross-object references (only references to objects which are direct properties of the object), this kind of instantiation is possible for all types of the process model. There are limitations on the usage of objects which are passed as parameters:
    • The implementations is allowed to expect that the objects are of the same implementation; e.g. the implementor Template method may expect the Nodes in the parameter to be of the same implementation or at least an extension of the same implementation.
      Example: If a DefaultTemplate object is constructed, the DefaultTemplate is allowed to expect DefaultNode objects (or extensions of DefaultNode) in the parameter.
    • NoteThis limitation is only valid for real graph elements, neither for container elements like Maps, Sets, etc. nor the proprietary container object like StructuredEdge!

    • Method Detail

      • createNode

        Node createNode​(int id,
                String name,
                String description,
                String staffAssignmentRule,
                ExecutableBusinessProcess executableBusinessProcess,
                boolean autoStart,
                UUID iconID,
                String groupName,
                String groupExecutionContext,
                Map<ActivityConstants.AccessType,​Map<String,​Integer>> parameterConnectorMapping,
                Map<ActivityConstants.AccessType,​Set<ProcessModelParameter>> systemParameters,
                Map<String,​Set<String>> supportedPlugins,
                Map<String,​PluginData> pluginData,
                Map<String,​String> userAttributes)
        Create a Node object.
        Parameters:
        id - The ID of the new node.
        name - The name of the new node.
        description - A description for the new node.
        staffAssignmentRule - The staff assignment rule for the new node.
        executableBusinessProcess - The EBP for the new node.
        autoStart - Whether the node could be started automatically.
        iconID - The icon ID of the new node.
        groupName - The name of the group this node can be part of, null or the empty string for a node that cannot be part of a group.
        groupExecutionContext - The execution context of the group this node can be part of, null or the empty string for a group for structuring purpose. The execution context specifies the UI element to use for the combined execution of the nodes of the group.
        parameterConnectorMapping - Mapping from access type to parameter name, to connector ID.
        systemParameters - Mapping from access type to parameters.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined Attributes for the new node.
        Returns:
        A new Node object.

      • createEdge

        Edge createEdge​(ProcessConstants.EdgeType type,
                long edgeCode,
                Map<String,​String> userAttributes)
        Create an Edge.
        Parameters:
        type - The type of the new edge.
        edgeCode - The edge code of the new edge.
        userAttributes - User defined attributes for the new edge.
        Returns:
        A new Edge object.

      • createTemplate

        Template createTemplate​(UUID id,
                        String name,
                        String description,
                        ConfigurationDescription configurationDescription,
                        Configuration configuration,
                        Configuration testConfiguration,
                        String processType,
                        QualifiedAgent supervisorAgent,
                        String version,
                        Set<ProcessModelParameter> inputParameters,
                        Set<ProcessModelParameter> outputParameters,
                        TemplateDeltaLayer deltaLayer,
                        Collection<Node> nodes,
                        Collection<DataElement> dataElements,
                        Set<StructuredEdge> edges,
                        Set<StructuredDataEdge> dataEdges,
                        Map<Integer,​ProcessModelFactory.StructuralNodeData> structuralNodeData,
                        Map<Integer,​List<Integer>> nodeDisabledConnectors,
                        int startNodeID,
                        int endNodeID,
                        String instanceNameTemplate,
                        Map<String,​Set<String>> supportedPlugins,
                        Map<String,​PluginData> pluginData,
                        Map<String,​String> userAttributes)
        Create a Template.
        Parameters:
        id - The ID of the new template.
        name - The name of the new template.
        description - The description of the new template.
        processType - The process Type of the new template.
        supervisorAgent - The supervisor agent of the new template.
        version - The version of the new template.
        inputParameters - The input parameters of the new template.
        outputParameters - The output parameters of the new template.
        deltaLayer - The delta layer of the new template.
        nodes - The nodes the new template contains.
        dataElements - The data elements the new template contains.
        edges - The edges the new template contains.
        dataEdges - The dataEdges the new template contains.
        structuralNodeData - A map from the ID of the node to its structural data.
        nodeDisabledConnectors - The connectors of a node, which have been disabled (key is the node ID, List are the IDs of the disabled connectors).
        startNodeID - The ID of the start node of the new template.
        endNodeID - The ID of the end node of the new template.
        instanceNameTemplate - The pattern for the name of an instance of this template.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined attributes for the new template.
        Returns:
        A new Template object.

      • createTemplateReference

        TemplateReference createTemplateReference​(UUID templateID,
                                          String processType,
                                          String version,
                                          String name,
                                          String description,
                                          QualifiedAgent supervisorAgent,
                                          Set<ProcessModelParameter> inputParameters,
                                          Set<ProcessModelParameter> outputParameters,
                                          Map<String,​Set<String>> supportedPlugins,
                                          Map<String,​PluginData> pluginData,
                                          Map<String,​String> userAttributes,
                                          boolean topLevelUsable,
                                          ProcessConstants.TemplateUsage usageAsSubprocess,
                                          ProcessConstants.TemplateBuildtimeState buildtimeState,
                                          boolean derivable,
                                          boolean spOutdated,
                                          boolean tlOutdated,
                                          boolean spInstantiable,
                                          boolean tlInstantiable,
                                          boolean spMigratable,
                                          boolean tlMigratable,
                                          boolean spChangeable,
                                          boolean tlChangeable)
        Create a TemplateReference.
        Parameters:
        templateID - The ID of the template.
        processType - The process type of the template.
        version - The version of the template.
        name - The name of the template.
        description - The description of the template.
        supervisorAgent - The supervisor agent of the template.
        inputParameters - The input parameters of the template.
        outputParameters - The output parameters of the template.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined attributes for the new template.
        topLevelUsable - Whether the template is top level usable.
        usageAsSubprocess - The usage as subprocess of the template.
        buildtimeState - The buildtime state of the template.
        derivable - Whether the template is derivable.
        spOutdated - Whether the template is outdated (subprocess scope).
        tlOutdated - Whether the template is outdated (toplevel scope).
        spInstantiable - Whether the template is instantiable (subprocess scope).
        tlInstantiable - Whether the template is instantiable (toplevel scope).
        spMigratable - Whether the template is migratable (subprocess scope).
        tlMigratable - Whether the template is migratable (toplevel scope).
        spChangeable - Whether the template is changeable (subprocess scope).
        tlChangeable - Whether the template is changeable (toplevel scope).
        Returns:
        A new TemplateReference object.

      • createRootTemplateNode

        WritableTemplateNode createRootTemplateNode​(TemplateReference templRef,
                                            Set<DataElement> dataElements)
        Create a root template node that allows for building template trees for the designated top-level template.
        Parameters:
        templRef - The template the created template node refers to.
        dataElements - The data elements of the referenced template.
        Returns:
        A new template node referring to the designated top-level template.

      • createTemplateNode

        WritableTemplateNode createTemplateNode​(TemplateReference templRef,
                                        Set<DataElement> dataElements,
                                        int nodeId)
        Create a template node as child of another template node.
        Parameters:
        templRef - The template the created template node refers to.
        dataElements - The data elements of the referenced template.
        nodeId - The ID of the node the designated template is being referenced as subprocess.
        Returns:
        A new template node referring to the designated template.

      • createInstanceNode

        InstanceNode createInstanceNode​(InstanceReference instRef,
                                UUID baseTemplId)
        Creates an instance node that allows for building instance trees for a top-level instance.
        Parameters:
        instRef - The top-level instance the created instance node refers to.
        baseTemplId - The templateId the instance node is based on.
        Returns:
        A new instance node referring to the designated top-level instance.

      • createInstanceNode

        InstanceNode createInstanceNode​(InstanceReference instRef,
                                UUID baseTemplId,
                                int iteration)
        Creates an instance node that allows for building instance trees for a child instance outside of a var par.
        Parameters:
        instRef - The child instance the created instance node refers to.
        baseTemplId - The templateId the instance node is based on.
        iteration - The iteration of the parent node the instance has been created in.
        Returns:
        A new instance node referring to the designated child instance.

      • createVarParInstanceNode

        InstanceNode createVarParInstanceNode​(InstanceReference instRef,
                                      UUID baseTemplId,
                                      int iteration,
                                      int varParIndex)
        Creates an instance node of a varpar that allows for building instance trees.
        Parameters:
        instRef - The varpar instance the created instance node refers to.
        baseTemplId - The templateId the created instance node is based on.
        iteration - The iteration of the parent node the instance has been created in.
        varParIndex - The index of the designated instance in the varpar.
        Returns:
        A new instance node referring to the designated varpar instance.

      • createDefaultTemplateStatus

        TemplateStatus createDefaultTemplateStatus​(UUID templateID)
        Create an initial TemplateStatus object with all comments set to "initial template status".
        Parameters:
        templateID - The ID of the template this status object belongs to.
        Returns:
        A new TemplateStatus object with default values

      • createTemplateStatus

        TemplateStatus createTemplateStatus​(UUID templateID,
                                    ProcessConstants.TemplateBuildtimeState buildtimeState,
                                    ProcessConstants.TemplateUsage subprocessUsage,
                                    boolean topLevelUsage,
                                    boolean derivable,
                                    String derivableComment,
                                    boolean tlOutdated,
                                    String tlOutdatedComment,
                                    boolean spOutdated,
                                    String spOutdatedComment,
                                    boolean tlInstantiable,
                                    String tlInstantiableComment,
                                    boolean spInstantiable,
                                    String spInstantiableComment,
                                    boolean tlInstancesMigratableTo,
                                    String tlInstancesMigratableComment,
                                    boolean spInstancesMigratableTo,
                                    String spInstancesMigratableComment,
                                    boolean tlInstancesChangeable,
                                    String tlInstancesChangeableComment,
                                    boolean spInstancesChangeable,
                                    String spInstancesChangeableComment,
                                    String starterRule)
        Create a TemplateStatus object with all comments set as provided.
        Parameters:
        templateID - The ID of the template this status object belongs to.
        buildtimeState - The TemplateBuildtimeState of this template specifying whether changes are allowed.
        subprocessUsage - How the template may be used as subprocess.
        topLevelUsage - Whether the template may be used and instantiated as top-level process
        derivable - Whether the template is derivable or not.
        derivableComment - The derivable comment.
        tlOutdated - Whether the template is outdated for top-level usage.
        tlOutdatedComment - The outdated comment for top-level usage.
        spOutdated - Whether the template is outdated for subprocess usage.
        spOutdatedComment - The outdated comment for subprocess usage.
        tlInstantiable - Whether the template is instantiable as top-level.
        tlInstantiableComment - The instantiable comment for top-level usage.
        spInstantiable - Whether the template is instantiable as subprocess.
        spInstantiableComment - The instantiable comment for subprocess usage.
        tlInstancesMigratableTo - Whether parent top-level instances may be migrated to the template.
        tlInstancesMigratableComment - The migratable comment for top-level usage.
        spInstancesMigratableTo - Whether parent subprocess instances may be migrated to the template.
        spInstancesMigratableComment - The migratable comment for subprocess usage.
        tlInstancesChangeable - Whether top-level instances are changeable.
        tlInstancesChangeableComment - The changeable comment for top-level usage.
        spInstancesChangeable - Whether subprocess instances are changeable.
        spInstancesChangeableComment - The changeable comment for subprocess usage.
        starterRule - The staff assignment rule which specifies which agent may create and start an instance of this template.
        Returns:
        A new TemplateStatus object

      • createTemplateProxy

        TemplateProxy createTemplateProxy​(TemplateReference templRef,
                                  UUID parent,
                                  List<UUID> children,
                                  Set<URI[]> deployedPm,
                                  long creationTime,
                                  long modificationTime,
                                  String internalVersion,
                                  QualifiedAgent lockingAgent)
        Creates a new template proxy.
        Parameters:
        templRef - A lightweight object representing the template.
        parent - The ID of the parent template of the template the proxy represents.
        children - The IDs of the derived children of the template the proxy represents. The children have to be sorted by their creation date.
        deployedPm - The ProcessManagers the template is deployed to.
        creationTime - The time the template was created.
        modificationTime - The time the template was last modified.
        internalVersion - The internal version number.
        lockingAgent - The current locking agent.
        Returns:
        A template proxy with the designated field values.

      • createProcessType

        ProcessType createProcessType​(String name,
                              TemplateProxy templateProxy)
        Creates a new process type.
        Parameters:
        name - The name of the process type.
        templateProxy - The proxy of the root template of the process type.
        Returns:
        A process type with the designated field values.

      • createInstanceLwpIts

        Instance createInstanceLwpIts​(UUID id,
                              UUID logId,
                              String name,
                              boolean isModified,
                              UUID baseTemplateId,
                              Template template,
                              QualifiedAgent supervisorAgent,
                              QualifiedAgent initiatorAgent,
                              EBPInstanceReference ebpInstanceReference,
                              long creationTime,
                              Map<Integer,​ProcessConstants.NodeState> nodeStates,
                              Map<Integer,​Integer> nodeIterations,
                              Map<Integer,​ProcessConstants.ExecutionMode> nodeExecutionModes,
                              Map<Integer,​Map<Integer,​List<UUID>>> nodeLwpInstanceIds,
                              Map<Integer,​QualifiedAgent> activityAgents,
                              Map<String,​Set<String>> supportedPlugins,
                              Map<String,​PluginData> pluginData,
                              Map<String,​String> userAttributes)
        Create an Instance.
        Parameters:
        id - The ID of the instance.
        logId - The log ID of the instance.
        name - The name of the instance.
        isModified - Whether the instance previously has been modified.
        baseTemplateId - The ID of the base template.
        template - The template or instance delta layer with the structural information on the instance.
        supervisorAgent - The supervisor agent of the instance.
        initiatorAgent - The initiatorAgent of the instance.
        ebpInstanceReference - If the instance is a sub process, this contains an "up-reference" to the super process. Else it is null.
        creationTime - The creation time of the instance.
        nodeStates - The states of the nodes, key is the node ID, value is the NodeState.
        nodeIterations - The iterations of the nodes, key is the node ID.
        nodeExecutionModes - The execution modes of the nodes, key is the node ID.
        nodeLwpInstanceIds - The instance IDs of subprocesses at a node, key is the node ID, inner key is the iteration.
        activityAgents - The assigned agents of an activity in the current iteration of the node, key is the node ID.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined attributes for the new template.
        Returns:
        A new Instance object.

      • createInstanceReference

        InstanceReference createInstanceReference​(UUID id,
                                          UUID logID,
                                          String name,
                                          boolean isModified,
                                          TemplateReference template,
                                          QualifiedAgent supervisorAgent,
                                          QualifiedAgent initiatorAgent,
                                          long creationTime,
                                          UUID parentInstanceID,
                                          ProcessConstants.InstanceExecutionStatus executionStatus,
                                          Map<String,​Set<String>> supportedPlugins,
                                          Map<String,​PluginData> pluginData,
                                          Map<String,​String> userAttributes)
        Create an InstanceReference.
        Parameters:
        id - The ID of the instance.
        logID - The log ID of the instance.
        name - The name of the instance.
        isModified - Whether the instance is modified.
        template - The reference to the template.
        supervisorAgent - The supervisor agent of the instance.
        initiatorAgent - The initiator agent of the instance.
        parentInstanceID - The instanceID of the parent instance, if this is a subprocess-instance, or null.
        executionStatus - The execution status of the instance.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined attributes for the new template.
        Returns:
        A new InstanceReference object.

      • createInstanceHistories

        InstanceHistories createInstanceHistories​(UUID instanceID,
                                          Document executionHistoryXML,
                                          Document changeHistoryXML)
        Creates an object containing all histories of an instance.
        Parameters:
        instanceID - The ID of the instance, the histories belong to.
        executionHistoryXML - The execution history as DOM document.
        changeHistoryXML - The change history as DOM document.
        Returns:
        A new instance histories object.

      • createEBPInstanceReference

        EBPInstanceReference createEBPInstanceReference​(EBPType type,
                                                UUID instanceID,
                                                UUID instanceLogID,
                                                UUID baseTemplateID,
                                                int nodeID,
                                                int nodeIteration,
                                                URI[] executionManagerURIs)
        Create a new EBP instance reference object.
        Parameters:
        type -
        instanceID - The (logical) ID of the instance.
        instanceLogID - The (unchangeable) log ID of the instance.
        baseTemplateID -
        nodeID - The ID of the node.
        nodeIteration - The ID of the node iteration.
        executionManagerURIs - The communication protocol depended references to the execution manager managing the execution of the referenced EBP/the containing node.
        Returns:
        A new EBP instance reference object.

      • createEBPInstanceReference

        EBPInstanceReference createEBPInstanceReference​(EBPType type,
                                                UUID instanceID,
                                                UUID instanceLogID,
                                                UUID baseTemplateID,
                                                int nodeID,
                                                int nodeIteration,
                                                URI[] executionManagerURIs,
                                                URI[] runtimeManagerURIs)
        Create a new EBP instance reference object.
        Parameters:
        type -
        instanceID - The (logical) ID of the instance.
        instanceLogID - The (unchangeable) log ID of the instance.
        baseTemplateID -
        nodeID - The ID of the node.
        nodeIteration - The ID of the node iteration.
        executionManagerURIs - A reference to the execution manager managing the execution of the referenced EBP/the containing node.
        runtimeManagerURIs - A reference to the runtime manager which is/was used for execution of the referenced EBP.
        Returns:
        A new EBP instance reference object.

      • createEBPInstanceReference

        EBPInstanceReference createEBPInstanceReference​(int nodeID,
                                                Instance instance,
                                                URI[] executionManagerURIs)
        Create a new EBP instance reference object for the designated node of the designated instance being from the designated execution manager. The iteration will be the current iteration of the node.
        Parameters:
        nodeID - The ID of the node.
        instance - The instance for which to retrieve an EBP instance reference for the designated node.
        executionManagerURIs - The communication protocol depended references to the execution manager managing the execution of the designated instance.
        Returns:
        A new EBP instance reference object.

      • createInstanceStatus

        InstanceStatus createInstanceStatus​(UUID instanceID,
                                    ProcessConstants.InstanceMigrationStatus migrationStatus,
                                    String migrationStatusComment,
                                    ProcessConstants.InstanceExecutionStatus executionStatus,
                                    String executionStatusComment)
        Parameters:
        instanceID - The ID of the instance this status object belongs to.
        migrationStatus - The migration status of the instance.
        migrationStatusComment - The comment of the migration status.
        executionStatus - The execution status of the instance.
        executionStatusComment - The comment of the migration status.
        Returns:
        A new instance status object.

      • createInstanceStatus

        InstanceStatus createInstanceStatus​(UUID instanceID,
                                    ProcessConstants.InstanceMigrationStatus migrationStatus,
                                    long migrationStatusDate,
                                    String migrationStatusComment,
                                    ProcessConstants.InstanceExecutionStatus executionStatus,
                                    long executionStatusDate,
                                    String executionStatusComment)
        Parameters:
        instanceID - The ID of the instance this status object belongs to.
        migrationStatus - The migration status of the instance.
        migrationStatusDate - The date the designated migration status has been set.
        migrationStatusComment - The comment of the migration status.
        executionStatus - The execution status of the instance.
        executionStatusDate - The date the designated execution status has been set.
        executionStatusComment - The comment of the migration status.
        Returns:
        A new instance status object.

      • createProcessModelParameter

        ProcessModelParameter createProcessModelParameter​(String name,
                                                  String description,
                                                  ProcessConstants.AdeptDataType dataType,
                                                  String udtName,
                                                  UUID identifierID,
                                                  boolean isOptional,
                                                  boolean isVirtual,
                                                  boolean isFailure,
                                                  String defaultValue,
                                                  ActivityConfiguration configuration,
                                                  PluginDataContainer pluginData,
                                                  Map<String,​String> userAttributes)
        Create a process model parameter object.
        Parameters:
        name - The name of the parameter.
        dataType - The type of the parameter.
        udtName - A user defined type for the parameter.
        identifierID - The identifierID of the parameter.
        isOptional - Whether the parameter is optional.
        description - A description of the parameter.
        isVirtual - Whether the parameter is virtual.
        Returns:
        A new Parameter object.

      • createConfiguration

        ChangeableActivityConfiguration createConfiguration​(ActivityConfiguration template)
        Creates a new ChangeableActivityConfiguration containing the values from the given template. This may be null to create an empty configuration.
        Parameters:
        template - the template to take the values from or null to create an empty configuration
        Returns:
        a new ChangeableActivityConfiguration

      • createDataElement

        DataElement createDataElement​(int id,
                              String name,
                              ProcessConstants.AdeptDataType type,
                              String description,
                              String userDefinedType,
                              UUID iconID,
                              UUID identifierID,
                              boolean isPublic,
                              boolean virtual,
                              Map<String,​Set<String>> supportedPlugins,
                              Map<String,​PluginData> pluginData,
                              Map<String,​String> userAttributes)
        Create a DataElement.
        Parameters:
        id - The ID of the data element.
        type - The type of the data element.
        name - The name of the data element.
        description - A description of the data element.
        userDefinedType - A user defined type for the data element.
        iconID - The iconID of the data element.
        identifierID - The identifierID of the data element.
        isPublic - Whether the data element is public
        virtual - Whether the data element is virtual.
        supportedPlugins - Mapping from extensionPointID to pluginIDs.
        pluginData - Mapping from pluginID to plugin data.
        userAttributes - User defined attributes for the data element.
        Returns:
        A new DataElement object.

      • createDataEdge

        DataEdge createDataEdge​(ActivityConstants.AccessType type,
                        boolean optional,
                        Map<String,​String> userAttributes)
        Create a data edge.
        Parameters:
        type - The type of the data edge.
        optional - Whether the data edge is optional.
        userAttributes - User defined Attributes for the data edge.
        Returns:
        A new data edge object.

      • createEmbeddedProcess

        EmbeddedProcess createEmbeddedProcess​(Template embeddedTemplate,
                                      UUID parentTemplateID,
                                      UUID ownInternalID,
                                      Configuration configuration,
                                      Configuration testConfiguration,
                                      ExecutionControlProperties executionControlProperties,
                                      PluginDataContainer pluginData,
                                      Map<String,​String> userAttributes)
        Creates an EmbeddedProcess object.
        Parameters:
        embeddedTemplate - The template object of the embedded process.
        parentTemplateID - The ID of the parent template which will be used for Template.getID() of the embedded template since an embedded template does not have an own ID to be used outside the ExecutionManager.
        ownInternalID - The internal ID of the template (which may be internally stored as reference); usually this ID is not interpreted. If it does not exist or is unknown, use null, it will be set when first storing the embedded template.
        executionControlProperties - the execution control properties ExecutableBusinessProcess.getExecutionControlProperties()
        userAttributes - User defined Attributes for the embedded process.
        Returns:
        A new EmbeddedProcess object.

      • createDecisionActivity

        DecisionActivity createDecisionActivity​(Activity activity,
                                        ProcessModelParameter decisionParameter,
                                        Map<Long,​Collection<DecisionStatement>> decisionMapping)
        Creates a new decision activity object, based on the given activity.
        Parameters:
        activity -
        decisionParameter -
        decisionMapping - The mapping from edge code to all of the corresponding decision statements.
        Returns:
        A decision activity object, based on the given activity.

      • createDecisionStatement

        DecisionStatement createDecisionStatement​(String decisionLabel,
                                          String decisionStatement,
                                          long decisionId,
                                          Map<String,​Set<String>> supportedPlugins,
                                          Map<String,​PluginData> pluginData,
                                          Map<String,​String> userAttributes)
        Creates a new decision statement object.
        Parameters:
        decisionLabel -
        decisionStatement -
        decisionId -
        supportedPlugins - Mapping from extensionPointID to pluginIDs. This may be null.
        pluginData - Mapping from pluginID to plugin data. This may be null.
        userAttributes - The user attributes of the decision statement. This may be null.
        Returns:
        The decision statement implementation having the designated attributes.

      • createNullTemplate

        Template createNullTemplate​(QualifiedAgent supervisorAgent)
        Creates a null template using the underlaying implementation. A null template is a template having only a start and an end node.

        The template will have a random ID.

        Parameters:
        supervisorAgent - The agent who creates the new template
        Returns:
        A null template.

      • createStructuredEdge

        StructuredEdge createStructuredEdge​(Edge edge,
                                    int sourceNodeID,
                                    int destinationNodeID)
        Create a structured edge (a container for an edge and its structural information).
        Parameters:
        edge - The edge object.
        sourceNodeID - The source node ID of the edge.
        destinationNodeID - The destination node ID of the edge.
        Returns:
        A new structured edge.

      • createStructuredDataEdge

        StructuredDataEdge createStructuredDataEdge​(DataEdge dataEdge,
                                            int nodeID,
                                            int connectorID,
                                            int dataElementID)
        Create a structured data edge (a container for a data edge and its structural information).
        Parameters:
        dataEdge - The data edge object.
        nodeID - The source node ID of the data edge.
        connectorID - The ID of the connector.
        dataElementID - The ID of the data element.
        Returns:
        A new structured data edge.

      • createStructuralNodeData

        ProcessModelFactory.StructuralNodeData createStructuralNodeData​(int nodeID,
                                                                ProcessConstants.NodeType nodeType,
                                                                int topologicalID,
                                                                int branchID,
                                                                int splitNodeID,
                                                                int correspondingBlockNodeID)
        Create a temporary object, containing all structural information of a node.
        Parameters:
        nodeID - The ID of the node.
        nodeType - The type of the node.
        topologicalID - The topological ID of the node.
        branchID - The branch ID of the node.
        splitNodeID - The split node ID of the node.
        correspondingBlockNodeID - The corresponding block node ID.
        Returns:
        The structural information of a node.