Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.fujitsu.iflow.model.workflow
Interface Node

All Known Subinterfaces:
  NodeInstance

public interface Node

The `Node` interface includes all the methods that can be used with nodes in a process definition.

You can retrieve all nodes in a process definition with the `getNodes` method from the `Plan` interface. Then you can iterate through the nodes and display information about them using the methods in the `Node` interface.

The `Node` interface is an object that is subordinate to the process definition (`Plan` interface). It is used in the design of node objects in process definitions, to retrieve the node information from a process definition, or to write a graphical editor.

The `Node` interface contains methods for all of the existing node types. Some methods (such as `supportRole`) assist a client in classifying a node according to its function.

The standard way of constructing a new `Node` object is to call the method `Plan.addNode`. This method creates and returns a new `Node` instance to the process definition. The attributes of the new node can then be modified by the methods in the `Node` interface.

A node is the part of the process definition that defines the `NodeInstance` and `WorkItem` instances that are created during the execution of the process instance in which they are defined. It specifies the behaviour of these instances in the process instance.

`String` parameters of all methods in this class have a length limit. This limit is documented in the Javadoc description of each parameter. If the length of a value supplied for such a parameter exceeds this limit or the value is `null`, an exception is thrown. This exception is a subclass of `ModelException`. For future compatibility, only `ModelException` should be caught explicitly.

If the signature of a method does not allow the throwing of exceptions, any value supplied to this method that exceeds the length limit is truncated to the maximum length supported. `null` values are ignored in this case. Any method’s behaviour that differs from the behaviour described above is explained in this method’s Javadoc description.

Exceptions. Three kinds of exceptions are commonly thrown within this class: `WFServerException`, `WFInternalException`, and `ModelInternalException`, all of which are instances of `ModelException`. In the methods that directly throw a `ModelException`, this exception usually wraps one of the former three exceptions. `WFServerException` indicates that the server failed to operate normally. `WFInternalException` indicates a problem in the communication between client and server. As its name suggests, `util.ModelInternalException` denots other problems that are internal to the Model API.

See Also:
  `Plan`

Field Summary
`static int` | `MAX_CUSTOM_NODE_TYPE_LENGTH` Specifies the maximum length of the custom node type; currently 256 characters.
`static int` | `MAX_NODE_DESCRIPTION_LENGTH` Specifies the maximum length of the node description; currently 256 characters.
`static int` | `MAX_NODE_NAME_LENGTH` Specifies the maximum length of the node name; currently 30 characters.
`static int` | `MAX_PLAN_URI_LENGTH` Specifies the maximum length of the plan uri; currently 2000 characters.
`static int` | `ON_EVERY_VOTE` This constant specifies the mode of evaluation (set by `setEvaluateRulesMode`) which is only supported in the voting activity node (type `TYPE_VOTING_ACTIVITY`).
`static int` | `TYPE_ACTIVITY` Identifies this node type as an activity node.
`static int` | `TYPE_AND` Identifies this node type as an AND node.
`static int` | `TYPE_CHAINED_PROCESS` Identifies this node type as a chained-process node.
`static int` | `TYPE_CONDITION` Identifies this node type as a conditional node.
`static int` | `TYPE_DELAY` Identifies this node type as a delay node.
`static int` | `TYPE_EXIT` Identifies this node type as an exit node.
`static int` | `TYPE_OR` Identifies this node type as an OR node.
`static int` | `TYPE_REMOTE_SUB_PROCESS` Identifies this node type as a remote subprocess node.
`static int` | `TYPE_START` Identifies this node type as a start node.
`static int` | `TYPE_SUB_PROCESS` Identifies this node type as a subprocess node.
`static int` | `TYPE_VOTING_ACTIVITY` Identifies this node type as a voting activity node.
`static int` | `WHEN_ALL_VOTES_ARE_CAST` This constant specifies the mode of evaluation (set by `setEvaluateRulesMode`) which is only supported in the voting activity node (type `TYPE_VOTING_ACTIVITY`).

Method Summary
`Arrow` | `addArrow(java.lang.String arrowName, int arrowType, Node targetNode)` Deprecated. Replaced by `addArrow(String, Node)`
`Arrow` | `addArrow(java.lang.String arrowName, Node targetNode)` Adds an arrow to this node.
`DataItemMappingElement` | `addDataMappingElement(java.lang.String parentDataItemRefName, java.lang.String childDataItemRefName, int direction)` Maps the flow of information between a User Defined Attribute (UDA) in the parent process and a UDA in the subprocess.
`FormRef` | `addForm(java.lang.String formName, java.lang.String formPath)` Adds a form to the node and returns the generated form object.
`TimerDef` | `addTimer(TimerDef timer)` Adds the timer specified in `timer` to this node.
`TriggerDef` | `addTrigger(java.lang.String name, int type)` Adds a new trigger definition with the given name and type to this node.
`boolean` | `equals(Node node)` Deprecated. Use `getNodeId() == node.getNodeId()` instead.
`long` | `getChainedPlanId()` Returns the ID of the process definition that is to be started as a chained process when this node is executed.
`java.lang.String` | `getChainedPlanName()` Returns the name of the process definition for which a new process instance is created and started when the execution of the process reaches this node.
`ConditionSpec` | `getConditionSpec()` Returns the specified `ConditionSpec` object of this node.
`java.lang.String` | `getCustomNodeType()` Returns the custom node type of this node.
`DataItemRef[]` | `getDataItemRefs()` Deprecated. This method is replaced by `getPlan().getDataItemRefs`
`DataItemMappingElement[]` | `getDataMappingElements()` Returns an array of `DataItemMappingElement`s that copy values between the parent process instance and the subprocess associated with this node.
`java.lang.String` | `getDefaultChoice()` Returns the outgoing arrow of this node that is defined as the default path to be used if none of the voting conditions is true.
`java.lang.String` | `getDesc()` Returns the description of this node.
`TimerDef` | `getDueDateDef()` Returns the due date for this node.
`JavaActionSet` | `getEpilogueJavaActionSet()` Returns the Epilogue `JavaActionSet` of this node.
`java.lang.String` | `getEpilogueScript()` Deprecated. Use JavaAction (`getEpilogueJavaActionSet`) instead of JavaScript.
`int` | `getEvaluateRulesMode()` Returns the current rules mode of voting evaluation as defined in the `Node` interface by constants such as `ON_EVERY_NODE`.
`java.lang.String[]` | `getEvaluationOrder()` Returns the arrow names of this node in the order of evaluation.
`org.w3c.dom.Document` | `getExtendedAttributes()` Returns the DOM document that contains all extended attributes of this node.
`FormRef` | `getForm(java.lang.String name)` Returns a reference to the form that corresponds to its name.
`FormRef[]` | `getForms()` Returns an array of `FormRef` objects containing references to all forms associated with this node.
`Arrow[]` | `getIncomingArrows()` Returns an array of all arrows entering this node.
`java.lang.String` | `getName()` Returns this node's name.
`long` | `getNodeId()` Returns this node's unique identifier.
`boolean` | `getNodeTxnStatus()` Returns `true` if the transaction will remain open after completing this node; `false` if the transaction will be committed after completing this node (default).
`Arrow[]` | `getOutgoingArrows()` Returns an array of all arrows leaving this node.
`Plan` | `getPlan()` Returns the process definition object to which this node belongs.
`java.lang.String` | `getPlanDescription()` Deprecated. This method is replaced by `getPlan.getDesc`.
`java.lang.String` | `getPlanName()` Deprecated. This method is replaced by `getPlan().getName`.
`java.lang.String` | `getPlanTitle()` Deprecated. This method is replaced by `getPlan().getTitle`.
`java.awt.Point` | `getPosition()` Returns the current position of this node.
`JavaActionSet` | `getPrologueJavaActionSet()` Returns the Prologue `JavaActionSet` of this node.
`java.lang.String` | `getPrologueScript()` Deprecated. Use JavaAction (`getPrologueJavaActionSet`) instead of JavaScript.
`java.lang.String` | `getRole()` Returns the role assigned to this node.
`JavaActionSet` | `getRoleJavaActionSet()` Returns the Role `JavaActionSet` for this node.
`java.lang.String` | `getRoleScript()` Deprecated. Use JavaAction (`getRoleJavaActionSet`) instead of JavaScript.
`long` | `getSubPlanId()` Deprecated. Use `getSubPlanName`.
`java.lang.String` | `getSubPlanName()` Returns the name of process definition which is called as a subprocess from this node.
`java.lang.String` | `getSubPlanURI()` Returns the URI of the remote process definition.
`TimerDef[]` | `getTimers()` Returns an array of all the timers associated with this node.
`TriggerDef` | `getTrigger(long triggerId)` Returns the trigger definition for the supplied ID.
`TriggerDef[]` | `getTriggers()` Returns all trigger definitions associated with this node.
`TriggerDef[]` | `getTriggers(int type)` Returns all trigger definitions of this node that are of the specified type.
`int` | `getType()` Returns the current type of this node as defined in the `Node` interface by constants such as `TYPE_ACTIVITY`.
`java.awt.Point` | `getUpperLeftPoint()` Returns the upper left point of this node.
`VotingRule` | `getVotingRule(java.lang.String arrowName)` Returns the current voting rule of a specified outgoing arrow of this node as defined in the `VotingRule` interface by constants such as `VotingRule.TYPE_MAJORITY`.
`VotingRule[]` | `getVotingRules()` Returns the complete list of defined voting rules for the outgoing arrows of this node.
`boolean` | `isCustomNodeType()` Returns `true` if this node is a custom node.
`void` | `removeArrow(long arrowId)` Removes the specified arrow from this node.
`void` | `removeDataMappingElement(DataItemMappingElement dataItem)` Removes a `DataItemMappingElement` object that maps the movement of data between the parent process instance and the subprocess associated with the work item.
`JavaActionSet` | `removeEpilogueJavaActionSet()` Removes the Epilogue `JavaActionSet` from this node.
`void` | `removeForm(java.lang.String formName)` Removes the form with the specified name from this node.
`JavaActionSet` | `removePrologueJavaActionSet()` Removes the Prologue `JavaActionSet` from this node.
`JavaActionSet` | `removeRoleJavaActionSet()` Removes the Role `JavaActionSet` from this node.
`void` | `removeTimer(TimerDef td)` Removes a timer from this node.
`void` | `removeTrigger(long triggerId)` Removes the specified trigger definition from this node.
`void` | `removeTriggers()` Removes all trigger definitions from this node.
`void` | `reorderTimers(TimerDef[] tds)` Specifies the sequence of timers on this node.
`void` | `setChainedPlanId(long planId)` Sets the unique identifier of the process definition that is started as a chained process when this node is executed.
`void` | `setChainedPlanName(java.lang.String planName)` Sets the name of the process definition that is to be started as a chained process from this node.
`void` | `setConditionSpec(ConditionSpec spec)` Deprecated. The ConditionSpec can be add to the Node by calling method `getConditionSpec()`
`void` | `setCustomNodeType(java.lang.String CustomNodeType)` Set the custom node type identifier for this node.
`void` | `setDefaultChoice(java.lang.String arrowName)` Defines the outgoing arrow of this node that is used as the default choice on a voting activity Node (if type is `TYPE_VOTING_ACTIVITY`).
`void` | `setDesc(java.lang.String description)` Sets the description of this node.
`TimerDef` | `setDueDateDef(TimerDef dd)` Set the due date for this node.
`void` | `setEpilogueJavaActionSet(JavaActionSet actionSet)` Sets the Epilogue `JavaActionSet` of this node.
`void` | `setEpilogueScript(java.lang.String script)` Deprecated. Use JavaAction (`setEpilogueJavaActionSet`) instead of JavaScript.
`void` | `setEvaluateRulesMode(int mode)` Sets the mode of voting evaluation which is only supported for nodes that allow voting.
`void` | `setEvaluationOrder(java.lang.String[] arrowNames)` Specifies the order of evaluation for arrrows outgoing from this node.
`void` | `setExtendedAttributes(org.w3c.dom.Document attrs)` Sets the extended attributes of this node, contained in the supplied DOM document.
`void` | `setForms(FormRef[] forms)` Adds array of `FormRef` objects containing references to form(s) to this node.
`void` | `setName(java.lang.String nodeName)` Sets the name of this node.
`void` | `setNodeInTxn(boolean holdOpen)` Sets the transaction flag on this node.
`void` | `setPosition(java.awt.Point pos)` Sets the position of this node.
`void` | `setPrologueJavaActionSet(JavaActionSet actionSet)` Sets the Prologue `JavaActionSet` of this node.
`void` | `setPrologueScript(java.lang.String script)` Deprecated. Use JavaAction (`setPrologueJavaActionSet`) instead of JavaScript.
`void` | `setRole(java.lang.String role)` Assigns a role to the node.
`void` | `setRoleJavaActionSet(JavaActionSet actionSet)` Sets the Role `JavaActionSet` of this node.
`void` | `setRoleScript(java.lang.String script)` Deprecated. Use JavaAction (`setRoleJavaActionSet`) instead of JavaScript
`void` | `setSubPlanId(long planId)` Deprecated. Use `setSubPlanName`.
`void` | `setSubPlanName(java.lang.String planName)` Sets the name of process definition that is called as a subprocess from this node.
`void` | `setSubPlanURI(java.lang.String subPlanURI)` Sets the URI of the remote process definition.
`void` | `setTimers(TimerDef[] timers)` Associates an array of timers with this node.
`void` | `setUpperLeftPoint(java.awt.Point point)` Sets the upper left point into this node.
`void` | `setVotingRule(java.lang.String arrowName, int votingRuleType, int threshold)` Sets the voting rule for the specified outgoing arrow.
`boolean` | `supportChainedProcess()` Returns `true` if this node supports the definition of a chained process.
`boolean` | `supportConditionSpec()` Returns `true` if this node supports a `ConditionSpec`; `false` otherwise.
`boolean` | `supportDelay()` Returns `true` if this node supports the definition of a process delay.
`boolean` | `supportEpilogueJavaActionSet()` Returns `true`if this node supports an Epilogue `JavaActionSet`.``
`boolean` | `supportEpilogueScript()` Deprecated. Use JavaAction (`supportEpilogueJavaActionSet`) instead of JavaScript.
`boolean` | `supportForm()` Returns `true` if this node supports forms.
`boolean` | `supportPrologueJavaActionSet()` Returns `true`if this node supports a Prologue `JavaActionSet`.``
`boolean` | `supportPrologueScript()` Deprecated. Use JavaAction (`supportPrologueJavaActionSet`) instead of JavaScript.
`boolean` | `supportRemoteSubProcess()` Returns `true` if this node supports remote subprocesses.
`boolean` | `supportRole()` Returns `true` if this node supports a role.
`boolean` | `supportRoleJavaActionSet()` Returns `true`if this node supports a Role `JavaActionSet`t.``
`boolean` | `supportRoleScript()` Deprecated. Use JavaAction (`supportRoleJavaActionSet`) instead of JavaScript
`boolean` | `supportSubProcess()` Returns `true` if this node supports the definition of a subprocess.
`boolean` | `supportTimer()` Returns `true` if this node supports the definition of timers.
`boolean` | `supportTrigger()` Returns `true` if the node supports triggers.
`boolean` | `supportVoting()` Returns `true` if this node supports voting.

Field Detail

### TYPE_START

    public static final int TYPE_START

  Identifies this node type as a start node.

  See Also:
    Constant Field Values

### TYPE_EXIT

    public static final int TYPE_EXIT

  Identifies this node type as an exit node.

  See Also:
    Constant Field Values

### TYPE_ACTIVITY

    public static final int TYPE_ACTIVITY

  Identifies this node type as an activity node.

  See Also:
    Constant Field Values

### TYPE_AND

    public static final int TYPE_AND

  Identifies this node type as an AND node.

  See Also:
    Constant Field Values

### TYPE_CONDITION

    public static final int TYPE_CONDITION

  Identifies this node type as a conditional node.

  See Also:
    Constant Field Values

### TYPE_OR

    public static final int TYPE_OR

  Identifies this node type as an OR node.

  See Also:
    Constant Field Values

### TYPE_SUB_PROCESS

    public static final int TYPE_SUB_PROCESS

  Identifies this node type as a subprocess node.

  See Also:
    Constant Field Values

### TYPE_DELAY

    public static final int TYPE_DELAY

  Identifies this node type as a delay node.

  See Also:
    Constant Field Values

### TYPE_CHAINED_PROCESS

    public static final int TYPE_CHAINED_PROCESS

  Identifies this node type as a chained-process node.

  See Also:
    Constant Field Values

### TYPE_VOTING_ACTIVITY

    public static final int TYPE_VOTING_ACTIVITY

  Identifies this node type as a voting activity node.

  See Also:
    Constant Field Values

### TYPE_REMOTE_SUB_PROCESS

    public static final int TYPE_REMOTE_SUB_PROCESS

  Identifies this node type as a remote subprocess node.

  See Also:
    Constant Field Values

### MAX_NODE_NAME_LENGTH

    public static final int MAX_NODE_NAME_LENGTH

  Specifies the maximum length of the node name; currently 30 characters.

  See Also:
    Constant Field Values

### MAX_NODE_DESCRIPTION_LENGTH

    public static final int MAX_NODE_DESCRIPTION_LENGTH

  Specifies the maximum length of the node description; currently 256 characters.

  See Also:
    Constant Field Values

### MAX_CUSTOM_NODE_TYPE_LENGTH

    public static final int MAX_CUSTOM_NODE_TYPE_LENGTH

  Specifies the maximum length of the custom node type; currently 256 characters.

  See Also:
    Constant Field Values

### MAX_PLAN_URI_LENGTH

    public static final int MAX_PLAN_URI_LENGTH

  Specifies the maximum length of the plan uri; currently 2000 characters.

  See Also:
    Constant Field Values

### ON_EVERY_VOTE

    public static final int ON_EVERY_VOTE

  This constant specifies the mode of evaluation (set by `setEvaluateRulesMode`) which is only supported in the voting activity node (type `TYPE_VOTING_ACTIVITY`). This constant specifies that voting rules should be evaluated on every vote.

  See Also:
    Constant Field Values

### WHEN_ALL_VOTES_ARE_CAST

    public static final int WHEN_ALL_VOTES_ARE_CAST

  This constant specifies the mode of evaluation (set by `setEvaluateRulesMode`) which is only supported in the voting activity node (type `TYPE_VOTING_ACTIVITY`). This constant specifies that voting rules should be evaluated only when all votes are cast.

  See Also:
    Constant Field Values

Method Detail

### supportConditionSpec

    public boolean supportConditionSpec()

  Returns `true` if this node supports a `ConditionSpec`; `false` otherwise. Not all nodes support the `ConditionSpecs`. This method allows you to determine whether or not this node supports the `ConditionSpec`.

  Returns:
    `true` if this node supports a `ConditionSpec`; `false` otherwise.
  See Also:
    `ConditionSpec`

### supportEpilogueScript

    public boolean supportEpilogueScript()

  Deprecated. Use JavaAction (`supportEpilogueJavaActionSet`) instead of JavaScript.

  Returns `true` if this node supports an epilogue script; `false` otherwise. Not all nodes support epilogue scripts. This method allows you to determine whether or not this node supports epilogue scripts.

  Returns:
    `true` if this node supports an epilogue script.
  See Also:
    `supportEpilogueJavaActionSet()`

### supportForm

    public boolean supportForm()

  Returns `true` if this node supports forms. Not all node types support forms, so this method allows you to determine whether or not this node supports forms.

  Returns:
    `true` if this node supports forms; `false` otherwise.

### supportPrologueScript

    public boolean supportPrologueScript()

  Deprecated. Use JavaAction (`supportPrologueJavaActionSet`) instead of JavaScript.

  Identifies if the node supports a prologue script. Not all node types support prologue scripts.

  Returns:
    `true` if this node supports a prologue script; `false` otherwise.
  See Also:
    `supportPrologueJavaActionSet()`

### supportRole

    public boolean supportRole()

  Returns `true` if this node supports a role. Not all node types support roles, so this method allows you to determine whether or not this node supports a role.

  Returns:
    `true` if this node supports a role; `false` otherwise.

### supportRoleScript

    public boolean supportRoleScript()

  Deprecated. Use JavaAction (`supportRoleJavaActionSet`) instead of JavaScript

  Identifies if the node supports a role script. Not all node types support role scripts. This method allows you to determine whether or not this node type uses a role script.

  Returns:
    `true` if the node supports a role script.
  See Also:
    `supportRoleJavaActionSet()`

### supportSubProcess

    public boolean supportSubProcess()

  Returns `true` if this node supports the definition of a subprocess. Not all nodes support subprocesses.

  Returns:
    `true` if this node supports a subprocess; `false` otherwise.

### supportChainedProcess

    public boolean supportChainedProcess()

  Returns `true` if this node supports the definition of a chained process. Not all nodes support chained processes.

  Returns:
    `true` if this node supports a chained process; `false` otherwise.

### supportDelay

    public boolean supportDelay()

  Returns `true` if this node supports the definition of a process delay. Only if the type of the node is `TYPE_DELAY` a process delay is supported. This method allows you to determine if this node supports this functionality.

  Returns:
    `true` if the node supports a process delay; `false` otherwise.

### supportTimer

    public boolean supportTimer()

  Returns `true` if this node supports the definition of timers. Not all nodes support timers, this method allows you to determine if this node supports timers or not.

  Returns:
    `true` if the node supports timers; `false` otherwise.

### supportRemoteSubProcess

    public boolean supportRemoteSubProcess()
                                    throws ModelException

  Returns `true` if this node supports remote subprocesses. Not all nodes support remote subprocesses. This method allows you to determine if this node supports remote subprocesses or not.

  Returns:
    `true` if the node supports remote subprocesses; `false` otherwise.
  Throws:
    `ModelException`

### getNodeId

    public long getNodeId()

  Returns this node's unique identifier. Each node in a process definition in Interstage BPM is identified by a unique ID. The ID is allocated automatically by the server when a process definition is created.

  Returns:
    This node's unique identifier.

### getName

    public java.lang.String getName()

  Returns this node's name. The name of a node is one method of identification. For example if the node's type is `TYPE_ACTIVITY` it is the name which is displayed to the user as the name of the work item.

  The name of the node is initialized while adding it to the process definition. It can be changed by calling method `setName`.

  Returns:
    The name of this node.
  See Also:
    `setName(String)`

### getDesc

    public java.lang.String getDesc()

  Returns the description of this node. The description field can contain a description of the work to be performed by this node. Returns an empty `String` when the description was not set before.

  Returns:
    A `String` containing the description of this node.
  See Also:
    `setDesc(String)`

### getType

    public int getType()

  Returns the current type of this node as defined in the `Node` interface by constants such as `TYPE_ACTIVITY`.

  The type of the node is initialized while adding it to the process definition.

  Returns:
    The integer constants specifying the type of this node.

### setName

    public void setName(java.lang.String nodeName)
                 throws ModelInternalException

  Sets the name of this node. It should be a short descriptive name that allows the user to easily identify what work must be done.

  The name is limited to `MAX_NODE_NAME_LENGTH` and must not contain any of the following characters: `\ | / : * ? " < >`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `nodeName` - The new name of this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied name is invalid (e.g. the length of name is 0) or `null`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getName()`

### setDesc

    public void setDesc(java.lang.String description)
                 throws ModelInternalException

  Sets the description of this node. The description can be used to document the work to be performed for the node. The description is limited to `MAX_NODE_DESCRIPTION_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `description` - The new description of this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied description is invalid or `null`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getDesc()`

### setNodeInTxn

    public void setNodeInTxn(boolean holdOpen)
                      throws ModelInternalException

  Sets the transaction flag on this node. This transaction flag is used to decide whether or not the transaction should be kept open when this node completes.

  A process instance often consists of a sequence of nodes. If this transaction flag is set to `false` for a particular node, then at the completion of execution of that node the transaction will be committed, and a new transaction will be created for the next node in the process sequence. If this flag is set to `true`, the transaction will not be committed, and the transaction will continue into the next node in the process sequence. There are two reasons to be concerned about this:

  1. The first consideration is performance.
     Committing the transaction saves everything to the database, and might force everything to be read from the database again to start the following transaction. If you have a long chain of nodes that do very little computation (for example a chain of branch nodes deciding among many possible directions) the overhead of saving to the database every time will be significant and unnecessary.
  2. The second consideration is errors and rollbacks.
     If a low level error occurs during processing, then the current transaction will be rolled back to the last commit point. If four nodes are all part of the same transaction, then on an error (or if the server loses power) all four nodes will be rolled back, and upon restart all four will be executed again. Committing the transaction somewhere in the middle means that it will rollback only to that point.

  Finally, keep in mind that any node that goes into a persistent wait state (such as an activity, or a subprocess node) necessarily commits the transaction. An activity participates in two transactions: one for the prologue actions, and another for the epilogue actions. This flag has no effect on the prologue transaction, but the flag will effect the transaction used with the epilogue actions. Epilogue actions are normally executed as part of the foreground transaction caused by the user upon completing the activity by making a choice. Setting this flag to `true` will mean that the transaction is not committed when the epilogue actions are done, and the following node (prologue at least) will be part of the same foreground transaction.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `holdOpen` - If the value of this parameter is `true`, the transaction of this node is not committed when the node completes, and the transaction stays open as the process moves into the next node. If `false, the transaction is committed.`
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getNodeTxnStatus()`

### getNodeTxnStatus

    public boolean getNodeTxnStatus()
                             throws ModelInternalException

  Returns `true` if the transaction will remain open after completing this node; `false` if the transaction will be committed after completing this node (default). This is called the "Node Transaction Status". It is a way of determining whether or not the node is set to complete in the same transaction.

  The default setting of this option is `false`.

  Returns:
    `true` if the transaction will remain open after completing this node; `false` if the transaction will be committed after completing this node (default).
  Throws:
    `ModelInternalException`

### addForm

    public FormRef addForm(java.lang.String formName,
                           java.lang.String formPath)
                    throws WFServerException,
                           WFInternalException,
                           ModelInternalException

  Adds a form to the node and returns the generated form object. There is no limit to how many forms you can add to a node.

  Adding forms to a node is only supported for one of the following types of nodes:

  - TYPE_START
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY

  Each form is specified by a name and a path, but it is not required that the `formPath` be a real path, or that it be formatted like a path. It is the client code that will interpret the meaning of the past value. Some clients want the value to be the path to an html file which displays the information. In other clients, the "path" is really a URL used for the purpose of redirection.

  Other clients need a command-line string that executes to display data to the user. The workflow engine does not examine or interpret the path, it only passes the value to the client. Therefore, the only requirement is that the plan receives a String value that will work for that particular client.

  The length of the form's path is limited to the number of characters specified by `FormRef.MAX_FORM_PATH_LENGTH`, and the form's name must not be longer than specified by `FormRef.MAX_FORM_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `formName` - A descriptive name of the form.
    `formPath` - The fully qualified path to the form.
  Returns:
    A form object that has been added to the node. This object can be used to manipulate form attributes.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied name or path is invalid (e.g. length is 0) or `null`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getForm(String)`, `getForms()`

### getForm

    public FormRef getForm(java.lang.String name)

  Returns a reference to the form that corresponds to its name.

  Forms are only supported for the following types of node:

  - TYPE_START
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY

  Returns `null` if no form is defined

  .

  Parameters:
    `name` - The form's name.
  Returns:
    The `FormRef` object corresponding to the specified name.
  See Also:
    `addForm(String, String)`, `setForms(FormRef[])`

### getForms

    public FormRef[] getForms()
                       throws ModelInternalException

  Returns an array of `FormRef` objects containing references to all forms associated with this node.

  Forms are only supported for the following types of node:

  - TYPE_START
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY

  Returns an empty array when no forms are associated with this node.

  Returns:
    An array of `FormRef` objects that represents all forms to be associated with the node.
  Throws:
    `ModelInternalException`
  See Also:
    `addForm(String, String)`, `setForms(FormRef[])`, `getForm(String)`

### setForms

    public void setForms(FormRef[] forms)
                  throws ModelInternalException

  Adds array of `FormRef` objects containing references to form(s) to this node. This method permits all of the forms to be associated with a node to be associated at one time. There is no limit to the number of forms that can be associated with a node.

  Adding forms is only supported for following types of node:

  - TYPE_START
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `forms` - An array of `FormRef` objects that represents all forms to be associated with the node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportForm()`, `getForms()`

### removeForm

    public void removeForm(java.lang.String formName)
                    throws WFServerException,
                           WFInternalException,
                           ModelInternalException

  Removes the form with the specified name from this node. The user sees the name of the form when viewing the work item. This method removes the form from the node, but it does not delete the form.

  The length of the form's name is limited to the number of characters specified by the constant `FormRef.MAX_FORM_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `formName` - The form's name.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied form name is invalid or null. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportForm()`

### getPlan

    public Plan getPlan()

  Returns the process definition object to which this node belongs.

  With initializing the node is automatically added to a process definition.

  Returns:
    The process definition object to which this node belongs.

### getPlanName

    public java.lang.String getPlanName()

  Deprecated. This method is replaced by `getPlan().getName`.

  Returns the name of the process definition to which this node belongs. The process definition name appears in the list of process definitions from which process instances can be created.

  See Also:
    `getPlan()`, `Plan.getName()`

### getPlanTitle

    public java.lang.String getPlanTitle()

  Deprecated. This method is replaced by `getPlan().getTitle`.

  Returns the title of the process definition to which this node belongs. The title is an attribute of the process definition.

  See Also:
    `getPlan()`, `Plan.getTitle()`

### getPlanDescription

    public java.lang.String getPlanDescription()

  Deprecated. This method is replaced by `getPlan.getDesc`.

  Returns the description of the process definition to which this node belongs. Each node in Interstage BPM contains a large field, up to 64K characters, that can be used for detailed descriptions.

  See Also:
    `getPlan()`, `Plan.getDesc()`

### getPosition

    public java.awt.Point getPosition()

  Returns the current position of this node.

  Each node has an X and Y coordinate to show where it resides on the canvas if it is shown graphically. This positioning information is implementation specific. If the position is not explicitly set, this method returns an empty `Point` object that contains 0 as x and y coordinates.

  Returns:
    A `Point` object that represents the node's position.
  See Also:
    `setPosition(Point)`

### setPosition

    public void setPosition(java.awt.Point pos)

  Sets the position of this node. Each node has an X and Y coordinate to show where it resides in the target area if it is shown graphically. This positioning information is implementation specific so it will depend on how the node is represented. When setting this parameter, choose a coordinate system that is appropriate for your implementation.

  The min and max range of x and y coordinate is -32768 and 32767. If the supplied coordinates exceeds this range, the position is not set. It is recommended to use positive values only since it is dependent on the GUI tool whether negative values are supported or not.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`. When not in edit-mode, calling this method will have no effect.

  Parameters:
    `pos` - A `Point` object that represents the node's position.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getPosition()`

### getEpilogueScript

    public java.lang.String getEpilogueScript()
                                       throws ModelInternalException

  Deprecated. Use JavaAction (`getEpilogueJavaActionSet`) instead of JavaScript.

  Returns the epilogue script of the node. The epilogue script is executed immediately after a choice has occurred during execution of the process instance. Once the epilogue script has been executed, if it exists, the choice for the node is committed.

  Returns:
    A String containing the epilogue script.
  Throws:
    `ModelInternalException` - Returns the `GET_EPILOGUE_SCRIPT_FAILED` error-code constant.
  See Also:
    `getEpilogueJavaActionSet()`

### setEpilogueScript

    public void setEpilogueScript(java.lang.String script)
                           throws ModelInternalException

  Deprecated. Use JavaAction (`setEpilogueJavaActionSet`) instead of JavaScript.

  Sets the epilogue script of the node. Each node handles the execution of the epilogue script differently.

  Parameters:
    `script` - A String containing the epilogue script.
  Throws:
    `ModelInternalException` - Returns the `SET_EPILOGUE_SCRIPT_FAILED` error-code constant.
  See Also:
    `supportEpilogueScript()`, `setEpilogueJavaActionSet(JavaActionSet)`

### getPrologueScript

    public java.lang.String getPrologueScript()
                                       throws ModelInternalException

  Deprecated. Use JavaAction (`getPrologueJavaActionSet`) instead of JavaScript.

  Returns the prologue script of the node.

  Returns:
    A String containing the script to be executed when the node is first activited.
  Throws:
    `ModelInternalException` - This exception returns the `GET_PROLOGUE_SCRIPT_FAILED` error-code constant.
  See Also:
    `supportPrologueScript()`, `getPrologueJavaActionSet()`

### setPrologueScript

    public void setPrologueScript(java.lang.String script)
                           throws ModelInternalException

  Deprecated. Use JavaAction (`setPrologueJavaActionSet`) instead of JavaScript.

  Sets the prologue script of the node. Each node handles the execution of the prologue script differently.

  Parameters:
    `script` - A String containing the script to be executed when the node is first activited.
  Throws:
    `ModelInternalException` - Returns the `SET_PROLOGUE_SCRIPT_FAILED` error-code constant.
  See Also:
    `supportPrologueScript()`, `setPrologueJavaActionSet(JavaActionSet)`

### getRole

    public java.lang.String getRole()
                             throws ModelInternalException

  Returns the role assigned to this node. Roles are only associated with activity nodes (`TYPE_ACTIVITY` and `TYPE_VOTING_ACTIVITY`) although you can use `JavaActionSet`s that address roles from any node type.

  Returns an empty `String` if it is not defined.

  Returns:
    The role's name assigned to this node.
  Throws:
    `ModelInternalException`
  See Also:
    `supportRole()`, `setRole(String)`, `setRoleJavaActionSet(JavaActionSet)`

### setRole

    public void setRole(java.lang.String role)
                 throws ModelInternalException

  Assigns a role to the node. Roles are only supported for following types of nodes:
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY

  Roles are resolved before the prologue and role `JavaActionSet`s are executed.

  The role value is limited to the number of characters specified by `DirectoryServices.MAX_DIR_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `role` - The role's name which will be assigned to this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied role name is invalid or null. Should be caught as ModelException for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getRole()`, `supportRole()`

### getRoleScript

    public java.lang.String getRoleScript()
                                   throws ModelInternalException

  Deprecated. Use JavaAction (`getRoleJavaActionSet`) instead of JavaScript.

  Returns the role script for the node. Role scripts are only supported in activity nodes.

  Returns:
    The script that will be used to set the role script.
  Throws:
    `ModelInternalException` - This exception returns the `GET_ROLE_SCRIPT_FAILED` error-code constant.
  See Also:
    `supportRole()`, `getRoleJavaActionSet()`

### setRoleScript

    public void setRoleScript(java.lang.String script)
                       throws ModelInternalException

  Deprecated. Use JavaAction (`setRoleJavaActionSet`) instead of JavaScript

  Sets the role script of the node. For activity nodes, the role script is executed immediately after the prologue script but before role resolution occurs.

  Parameters:
    `script` - the script that will be used to set the role script.
  Throws:
    `ModelInternalException` - This exception returns the `SET_ROLE_SCRIPT_FAILED` error-code constant.
  See Also:
    `supportRole()`, `setRoleJavaActionSet(JavaActionSet)`

### addArrow

    public Arrow addArrow(java.lang.String arrowName,
                          int arrowType,
                          Node targetNode)
                   throws WFServerException,
                          WFInternalException,
                          ModelInternalException

  Deprecated. Replaced by `addArrow(String, Node)`

  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException`

### addArrow

    public Arrow addArrow(java.lang.String arrowName,
                          Node targetNode)
                   throws ModelException

  Adds an arrow to this node.

  Adding arrows to a node is only supported for one of the following types of nodes:

  - TYPE_START
  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_CONDITION
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS
  - TYPE_DELAY
  - TYPE_OR
  - TYPE_AND

  The fundamental purpose of an arrow is to control the flow within a process instance. When a node completes the process instance moves from the tail of an arrow to the head of an arrow. There is no limit to the number of arrows you can have entering or leaving any node type (except for start nodes, which can not have any arrow entering them, or exit nodes which can not have any arrow leaving them).

  In the case of an activity node, in addition to controlling the flow of the process, the outgoing arrows act as choices for a user. What choice the user makes will control which arrow is taken for further execution of the process instance. Another situation is with condition nodes. Here the outgoing arrows signify the path that will be taken when a specific condition is met.

  The name of arrow must not be longer than specified in `Arrow.MAX_ARROW_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `arrowName` - The arrow's name.
    `targetNode` - This is the target `Node` object that will be the destination node for the created arrow.
  Returns:
    The new created `Arrow` object. This object can then be used to set attributes for the arrow.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied arrow name is invalid (e.g. the length is 0) or `null`.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `Arrow`

### getIncomingArrows

    public Arrow[] getIncomingArrows()

  Returns an array of all arrows entering this node. If there are none, an empty array is returned. There is no limit to the number of arrows that can enter any node (except a start node, that one always has no incoming arrows).

  Returns:
    An array of `Arrow` objects representing the arrows entering this node.

### getOutgoingArrows

    public Arrow[] getOutgoingArrows()

  Returns an array of all arrows leaving this node. There is no limit to the number of arrows that can leave any node (except an exit node, it always has no arrows leaving). If there are no outgoing arrows, an empty array is returned.

  Returns:
    An array of that contains all arrows that leave this node.

### removeArrow

    public void removeArrow(long arrowId)
                     throws WFServerException,
                            WFInternalException,
                            ModelInternalException

  Removes the specified arrow from this node. This can be used for either incoming or outgoing arrows.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `arrowId` - The unique integer identifier of the arrow to be removed.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`

### equals

    public boolean equals(Node node)

  Deprecated. Use `getNodeId() == node.getNodeId()` instead.

  Compares this node with another one.

  See Also:
    `getNodeId()`

### getConditionSpec

    public ConditionSpec getConditionSpec()
                                   throws ModelInternalException

  Returns the specified `ConditionSpec` object of this node. This operation is only applicable to conditional nodes (type of this node must be `TYPE_CONDITION`).

  If this node does not contain any `ConditionSpec` when this method is called, a new `ConditionSpec` object is created for this condition node.

  Returns:
    The `ConditionSpec` of this node.
  Throws:
    `ModelInternalException`

### setConditionSpec

    public void setConditionSpec(ConditionSpec spec)
                          throws ModelInternalException

  Deprecated. The ConditionSpec can be add to the Node by calling method `getConditionSpec()`

  Sets the `ConditionSpec` object of this node. This operation is only applicable to conditional nodes (type of this node must be `TYPE_CONDITION`).

  The process definition has to be in edit-mode before calling `setChainedPlanName`. Edit-mode is entered by calling method `Plan.startEdit`.

  Parameters:
    `spec` - The `ConditionSpec` of the node.
  Throws:
    `ModelInternalException`
  See Also:
    `Plan.startEdit()`

### getDataItemRefs

    public DataItemRef[] getDataItemRefs()

  Deprecated. This method is replaced by `getPlan().getDataItemRefs`

  Returns the array of all User Defined Attributes associated with this node.

  See Also:
    `getPlan()`, `Plan.getDataItemRefs()`

### setTimers

    public void setTimers(TimerDef[] timers)
                   throws ModelException

  Associates an array of timers with this node. Note that timers can only be associated with activity nodes (`TYPE_ACTIVITY` and `TYPE_VOTING_ACTIVITY`).

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `timers` - An array of `TimerDef` objects.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this methd is called. Should be caught as `ModelException` for future comaptibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getTimers()`

### addTimer

    public TimerDef addTimer(TimerDef timer)
                      throws ModelException

  Adds the timer specified in `timer` to this node. The properties of the timer are specified at design time as User Defined Attribute (UDA) names. The values associated with this `TimerDef` object can be set at run time through the use of UDAs. Note that this method is only applicable to activity nodes.

  Adding a timer to a node is only supported for one of the following types of nodes:

  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_DELAY

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `timer` - The `TimerDef` object to add.
  Returns:
    The new added `TimerDef` object.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this methd is called. Should be caught as `ModelException` for future comaptibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getTimers()`

### getTimers

    public TimerDef[] getTimers()
                         throws ModelException

  Returns an array of all the timers associated with this node. If there are none, an empty array is returned. Note that timers can only be associated with activity nodes.

  Returns:
    An array of `TimerDef` objects associated with this node.
  Throws:
    `ModelException`
  See Also:
    `setTimers(TimerDef[])`, `addTimer(TimerDef)`

### removeTimer

    public void removeTimer(TimerDef td)
                     throws ModelException

  Removes a timer from this node.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `td` - The `TimerDef` object to be removed.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `addTimer(TimerDef)`, `setTimers(TimerDef[])`

### reorderTimers

    public void reorderTimers(TimerDef[] tds)
                       throws ModelException

  Specifies the sequence of timers on this node.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `tds` - An array of `TimerDef` objects in the new firing sequence.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when calling this method. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`

### setSubPlanId

    public void setSubPlanId(long planId)
                      throws WFServerException,
                             WFInternalException,
                             ModelInternalException

  Deprecated. Use `setSubPlanName`.

  Sets the ID of the process definition that will be used for the subprocess.

  Parameters:
    `planId` - The ID of the subprocess definition.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Returns the `SET_CHAINED_PLANID_FAILED` error-code constant if the node does not support subprocesses.
  See Also:
    `setSubPlanName(String)`

### getSubPlanId

    public long getSubPlanId()
                      throws ModelInternalException

  Deprecated. Use `getSubPlanName`.

  Returns the ID of the process definition that will be used for the subprocess.

  Throws:
    `ModelInternalException` - if the node does not support subprocesses.
  See Also:
    `getSubPlanName()`

### setSubPlanName

    public void setSubPlanName(java.lang.String planName)
                        throws WFServerException,
                               WFInternalException,
                               ModelInternalException

  Sets the name of process definition that is called as a subprocess from this node. The defining of the name is only supported if this node is a subprocess node (type is `TYPE_SUB_PROCESS`). When the process execution reaches this node, which defines a subprocess, it creates a new instance of the process definition corresponding to this name.

  Since the argument parameter is the name of a process definition, it is limited to `Plan.MAX_PLAN_NAME_LENGTH` and must not contain any of the following characters: `\ | / : * ? " < >`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `planName` - The name of the subprocess definition.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied name is invalid (e.g. the length of name is 0) or `null`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `Plan.MAX_PLAN_NAME_LENGTH`, `getSubPlanName()`

### getSubPlanName

    public java.lang.String getSubPlanName()
                                    throws ModelInternalException

  Returns the name of process definition which is called as a subprocess from this node. The defining of a name is only supported if this node is a subprocess node (type is `TYPE_SUB_PROCESS`). If no sub plan is defined for this node, an empty `String` is returned.

  Returns:
    Name of subprocess definition.
  Throws:
    `ModelInternalException` - If the node does not support subprocesses.

### setSubPlanURI

    public void setSubPlanURI(java.lang.String subPlanURI)
                       throws ModelException

  Sets the URI of the remote process definition. Note, that this operation is only supported for remote sub process nodes (`TYPE_REMOTE_SUB_PROCESS`).

  The name is limited to `MAX_PLAN_URI_LENGTH` characters.

  The supplied subPlanURI also specifies if ASAP or SWAP is used as protocol. If no protocol is specified in the URL ASAP is used by default. Following sample shows how to specify the subPlanURI for the process definition PurchaseOrder:

  ASAP subPlanURI: `asap:http://ws2:49950/ibpm/jsp/ProcDef.jsp?planName=PurchaseOrder`
  or
  `http://ws2:49950/ibpm/jsp/ProcDef.jsp?planName=PurchaseOrder`

  SWAP subPlanURI:
  `swap:http://ws2:49950/ibpm/jsp/ProcDef.jsp?planName=PurchaseOrder`

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `subPlanURI` - The URI of the remote process definition.
  Throws:
    `ModelException` - Thrown when the current node is not a remote sub process node or if the process definition or process instance is not in edit-mode when this method is called.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportRemoteSubProcess()`, `getSubPlanURI()`

### getSubPlanURI

    public java.lang.String getSubPlanURI()
                                   throws ModelException

  Returns the URI of the remote process definition.

  Returns:
    The URI of the remote process definition.
  Throws:
    `ModelException` - Thrown when this node is not a remove sub process node (`TYPE_REMOTE_SUB_PROCESS`)
  See Also:
    `setSubPlanURI(String)`, `supportRemoteSubProcess()`

### addDataMappingElement

    public DataItemMappingElement addDataMappingElement(java.lang.String parentDataItemRefName,
                                                        java.lang.String childDataItemRefName,
                                                        int direction)
                                                 throws ModelException

  Maps the flow of information between a User Defined Attribute (UDA) in the parent process and a UDA in the subprocess. Note, that the mapping of UDA is only supported for the following types of nodes:
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS

  In general there is no defined precedence order to the mappings and therefore mapping two variables to one in either direction will yield unpredictable results. For example the mapping of a parent UDA a to two child UDAs b and c using the direction `DataItemMappingElement.OUT` or `DataItemMappingElement.INOUT` will have an unknown result because the values of the child UDAs b and c will be copied back to the same parent UDA. You will get the same unpredictable result if two different parent UDAs are copied to the same child UDA using the direction `IN` or `INOUT`.

  Note that Chained Process Instances run independent from the parent process instance. That means the parent process instance does not wait until the child process instances finishes. In this case a mapping direction like `DataItemMappingElement.OUT` or `DataItemMappingElement.INOUT` does not make any sense, because the UDA values of child process instance will never be returned to the parent process instance.

  The name of `parentDataItemRef` and `childDataItemRef` are links to `DataItemRef` objects, so the values must not be longer than specified in `DataItemRef.MAX_DATA_REF_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of the process definition or structural edit-mode of the process instance is required. Edit-mode of a process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `parentDataItemRefName` - Name of the UDA in the parent process instance to map.
    `childDataItemRefName` - Name of the UDA in the subprocess to map.
    `direction` - An integer which specifies the direction of data flow, defined in the `DataItemMappingElement` interface by constants like `IN`.
  Returns:
    DataItemMappingElement The new created mapping element.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied UDA names are invalid or null. Furthermore this exception is thrown if this node does not support subprocesses or if the data mapping element still exists.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportChainedProcess()`, `supportSubProcess()`, `DataItemMappingElement`

### getDataMappingElements

    public DataItemMappingElement[] getDataMappingElements()
                                                    throws ModelException

  Returns an array of `DataItemMappingElement`s that copy values between the parent process instance and the subprocess associated with this node. If there are none, an empty array is returned.

  Note that the mapping of User Defined Attributes (UDA) is only supported for subprocess nodes or chained-process nodes.

  Returns:
    A list of UDA mapping elements.
  Throws:
    `ModelException` - Thrown when this node does not support chained processes or subprocesses.
  See Also:
    `supportChainedProcess()`, `supportSubProcess()`, `addDataMappingElement(String, String, int)`

### removeDataMappingElement

    public void removeDataMappingElement(DataItemMappingElement dataItem)
                                  throws ModelException

  Removes a `DataItemMappingElement` object that maps the movement of data between the parent process instance and the subprocess associated with the work item.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `dataItem` - The mapping element to be removed.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`

### setChainedPlanId

    public void setChainedPlanId(long planId)
                          throws WFServerException,
                                 WFInternalException,
                                 ModelInternalException

  Sets the unique identifier of the process definition that is started as a chained process when this node is executed. Note, that this operation is only supported for chained-process nodes (`TYPE_CHAINED_PROCESS`).

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `planId` - The ID of process definition to be executed as a chained process.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `getChainedPlanId()`

### getChainedPlanId

    public long getChainedPlanId()
                          throws ModelInternalException

  Returns the ID of the process definition that is to be started as a chained process when this node is executed. Note that this operation is only supported for chained-process nodes (type = `TYPE_CHAINED_PROCESS`). If this node does not define any chained process, the method returns -1.

  Returns:
    The unique identifier of the process definition to be executed as a chained process.
  Throws:
    `ModelInternalException`
  See Also:
    `setChainedPlanId(long)`

### setChainedPlanName

    public void setChainedPlanName(java.lang.String planName)
                            throws WFServerException,
                                   WFInternalException,
                                   ModelInternalException

  Sets the name of the process definition that is to be started as a chained process from this node. The definition of a name is only supported if this node is a chained-process node (if type is `TYPE_CHAINED_PROCESS`). When the process execution reaches this node, which defines a chained process, it creates a new instance of process definition regarding to this name.

  Since the argument parameter is the name of a process definition, it is limited to `Plan.MAX_PLAN_NAME_LENGTH` and must not contain any of the following characters: `\ | / : * ? " < >`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `planName` - The name of the chained process definition.
  Throws:
    `WFServerException`
    `WFInternalException`
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied name is invalid (e.g. length of name is 0) or `null`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `Plan.MAX_PLAN_NAME_LENGTH`, `getChainedPlanName()`

### getChainedPlanName

    public java.lang.String getChainedPlanName()
                                        throws ModelInternalException

  Returns the name of the process definition for which a new process instance is created and started when the execution of the process reaches this node. Note that this operation is only supported for chained-process nodes (type = `TYPE_CHAINED_PROCESS`). Returns an empty `String` if no chained process is defined for this node.

  Returns:
    The name of the chained process definition.
  Throws:
    `ModelInternalException` - This exception is thrown if the node does not support chained processes.
  See Also:
    `setChainedPlanName(String)`

### supportPrologueJavaActionSet

    public boolean supportPrologueJavaActionSet()

  Returns `true`if this node supports a Prologue `JavaActionSet`. Not all node types support Prologue `JavaActionSet`. This method allows you to determine if this node supports an Prologue `JavaActionSet`.

  ``
  Returns:
    `true`if the node supports a Prologue `JavaActionSet`; `false` otherwise.``

### supportEpilogueJavaActionSet

    public boolean supportEpilogueJavaActionSet()

  Returns `true`if this node supports an Epilogue `JavaActionSet`. Not all node types support Epilogue `JavaActionSet`. This method allows you to determine if this node supports an Epilogue `JavaActionSet`.

  ``
  Returns:
    `true` if the node supports an Epilogue `JavaActionSet`; `false` otherwise.

### supportRoleJavaActionSet

    public boolean supportRoleJavaActionSet()

  Returns `true`if this node supports a Role `JavaActionSet`t. Not all node types support Role `JavaActionSet`. This method allows you to determine if this node supports a Role `JavaActionSet`.

  ``
  Returns:
    `true` if the node supports a Role `JavaActionSet`; `false` otherwise.

### getEpilogueJavaActionSet

    public JavaActionSet getEpilogueJavaActionSet()
                                           throws ModelInternalException

  Returns the Epilogue `JavaActionSet` of this node. The Epilogue `JavaActionSet` is executed immediately after a choice has occurred during execution of the process instance. Once the Epilogue `JavaActionSet` has been executed, if it exists, the choice on the node is committed.

  Note, that only following types of node support epilogue `JavaActionSet`s:

  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_CONDITION
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS
  - TYPE_DELAY
  - TYPE_AND
  - TYPE_OR

  Returns `null` if no `JavaActionSet` is defined.

  Returns:
    A `JavaActionSet` containing the Epilogue `JavaAction`s of this node.
  Throws:
    `ModelInternalException` - When this node does not support Epilogue `JavaActionSet`.
  See Also:
    `supportEpilogueJavaActionSet()`

### setEpilogueJavaActionSet

    public void setEpilogueJavaActionSet(JavaActionSet actionSet)
                                  throws ModelInternalException

  Sets the Epilogue `JavaActionSet` of this node. The Epilogue `JavaActionSet` is executed immediately after a choice has occurred during execution of the process instance. Once the Epilogue `JavaActionSet`has been executed, if it exists, the choice for the node is committed.

  Note, that only following types of node support epilogue `JavaActionSet`s:

  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS
  - TYPE_DELAY
  - TYPE_AND
  - TYPE_OR

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `actionSet` - An object containing a set of `JavaAction`s
  Throws:
    `ModelInternalException` - Thrown when process definition is not in edit-mode when this method is called, or if this node does not support Epilogue JavaAction sets. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportEpilogueJavaActionSet()`

### getPrologueJavaActionSet

    public JavaActionSet getPrologueJavaActionSet()
                                           throws ModelInternalException

  Returns the Prologue `JavaActionSet` of this node.

  Note, that only following types of node support prologue `JavaActionSet`s:

  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_CONDITION
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS
  - TYPE_DELAY

  Returns `null` if no `JavaActionSet` is defined.

  Returns:
    A `JavaActionSet` containing the Prologue JavaActions of this node.
  Throws:
    `ModelInternalException` - When this node does not support Prologue `JavaActionSet`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `supportPrologueJavaActionSet()`

### setPrologueJavaActionSet

    public void setPrologueJavaActionSet(JavaActionSet actionSet)
                                  throws ModelInternalException

  Sets the Prologue `JavaActionSet` of this node. The Prologue `JavaActionSet` is executed immediately before the node performs it tasks.

  Note, that only following types of node support prologue `JavaActionSet`s:

  - TYPE_ACTIVITY
  - TYPE_VOTING_ACTIVITY
  - TYPE_CONDITION
  - TYPE_SUB_PROCESS
  - TYPE_CHAINED_PROCESS
  - TYPE_DELAY

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `actionSet` - A set of `JavaAction`s.
  Throws:
    `ModelInternalException` - Thrown when process definition is not in edit-mode when this method is called, or if this node does not support Prologue `JavaActionSet`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportPrologueJavaActionSet()`

### getRoleJavaActionSet

    public JavaActionSet getRoleJavaActionSet()
                                       throws ModelInternalException

  Returns the Role `JavaActionSet` for this node. The Role `JavaActionSet` is evaluated during role resolution but before task assignment.

  Note, that Role `JavaActionSet`s are only supported in activity nodes (`TYPE_ACTIVITY` and `TYPE_VOTING_ACTIVITY`).

  Returns `null` if no `JavaActionSet` is defined.

  Returns:
    The set of JavaActions which are executed as Role JavaActions within this node.
  Throws:
    `ModelInternalException` - Thrown when this node does not support Role `JavaActionSet`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `supportRole()`, `setRoleJavaActionSet(JavaActionSet)`

### setRoleJavaActionSet

    public void setRoleJavaActionSet(JavaActionSet actionSet)
                              throws ModelInternalException

  Sets the Role `JavaActionSet` of this node. The Role `JavaActionSet` is evaluated during role resolution but before task assignment.

  Note, that Role `JavaActionSet`s are only supported in activity nodes (`TYPE_ACTIVITY` and `TYPE_VOTING_ACTIVITY`).

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `actionSet` - The set of JavaActions which will be executed as Role Java Actions of this node.
  Throws:
    `ModelInternalException` - Thrown when process definition is not in edit-mode when this method is called, or when this node does not support Role `JavaActionSet`. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportPrologueJavaActionSet()`, `getRoleJavaActionSet()`

### removeRoleJavaActionSet

    public JavaActionSet removeRoleJavaActionSet()
                                          throws ModelInternalException

  Removes the Role `JavaActionSet` from this node.

  Note, that Role JavaActions are only supported for acticity nodes.

  The set of Role JavaActions is executed immediately after the Prologue `JavaActionSet` but before role resolution occurs.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Returns:
    The `JavaActionSet` that is removed from this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or when this node does not support Role JavaActions. Should be caught as `ModelException` for future compatibility.
  See Also:
    `supportRoleJavaActionSet()`, `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `setRoleJavaActionSet(JavaActionSet)`

### removePrologueJavaActionSet

    public JavaActionSet removePrologueJavaActionSet()
                                              throws ModelInternalException

  Removes the Prologue `JavaActionSet` from this node.

  Note that not all types of node support Prologue `JavaActionSet`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Returns:
    The `JavaActionSet` that is removed from this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or when this node does not support Prologue JavaActions. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportPrologueJavaActionSet()`, `setPrologueJavaActionSet(JavaActionSet)`

### removeEpilogueJavaActionSet

    public JavaActionSet removeEpilogueJavaActionSet()
                                              throws ModelInternalException

  Removes the Epilogue `JavaActionSet` from this node.

  Note that not all types of node support Epilogue `JavaActionSet`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Returns:
    The `JavaActionSet` that is removed from this node.
  Throws:
    `ModelInternalException` - Thrown when the process definition is not in edit-mode when this method is called, or when this node does not support role Java Actions. Should be caught as `ModelException` for future compatibility.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportEpilogueJavaActionSet()`, `setEpilogueJavaActionSet(JavaActionSet)`

### supportVoting

    public boolean supportVoting()

  Returns `true` if this node supports voting.

  Note, that only nodes of the type `TYPE_VOTING_ACTIVITY` support voting.

  Returns:
    `true` if the node supports voting; `false` otherwise.

### setEvaluateRulesMode

    public void setEvaluateRulesMode(int mode)
                              throws ModelException

  Sets the mode of voting evaluation which is only supported for nodes that allow voting. The evalution rules mode defines when the voting should be evaluated. There are two different kinds of evaluation rule modes, which are defined as constants in this interface. The two types are:
  1. `ON_EVERY_VOTE`
  2. `WHEN_ALL_VOTES_ARE_CAST`

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `mode` - The integer constants specifying the current evaluation rules mode of this node.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called or when this node does not support voting.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportVoting()`, `getEvaluateRulesMode()`

### getEvaluateRulesMode

    public int getEvaluateRulesMode()
                             throws ModelException

  Returns the current rules mode of voting evaluation as defined in the `Node` interface by constants such as `ON_EVERY_NODE`. The evaluation rules mode is set to `ON_EVERY_NODE` per default.

  Note, that this functionality is only supported for nodes that allow voting.

  Returns:
    The integer constant specifying the current evaluation rules mode of this node.
  Throws:
    `ModelException` - Thrown when this node does not support voting.
  See Also:
    `supportVoting()`, `setEvaluateRulesMode(int)`

### setDefaultChoice

    public void setDefaultChoice(java.lang.String arrowName)
                          throws ModelException

  Defines the outgoing arrow of this node that is used as the default choice on a voting activity Node (if type is `TYPE_VOTING_ACTIVITY`). Voting activity nodes need to specify a default choice to be used when none of the voting conditions is true.

  The name of the arrow is a link to an `Arrow` object, so the length of the String specified as its value must not be longer than the limit specified in `Arrow.MAX_ARROW_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `arrowName` - Name of an existing outgoing arrow on this node.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called, or the supplied name is invalid or `null`. Furthermore this exception is thrown when this node does not support voting.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportVoting()`

### getDefaultChoice

    public java.lang.String getDefaultChoice()
                                      throws ModelException

  Returns the outgoing arrow of this node that is defined as the default path to be used if none of the voting conditions is true.

  Returns an empty `String` if no default choice is defined.

  Note, that this functionality is only supported for nodes that allow voting.

  Returns:
    The name of outgoing arrow which is used by default.
  Throws:
    `ModelException` - Thrown when this node does not support voting.
  See Also:
    `supportVoting()`, `setDefaultChoice(String)`

### setVotingRule

    public void setVotingRule(java.lang.String arrowName,
                              int votingRuleType,
                              int threshold)
                       throws ModelException

  Sets the voting rule for the specified outgoing arrow. This functionality is only supported for voting nodes (`TYPE_VOTING_ACTIVITY`).

  The voting rule defines the kind of controls in place for voting. The possible voting rules are specified in the `VotingRule` interface by constants such as `VotingRule.TYPE_MAJORITY`. The threshold of a voting rule defines the limit when the condition becomes true. The threshold is ignored when the `votingRuleType` is `VotingRule.TYPE_MAJORITY`.

  The name of the arrow is a link to an `Arrow` object, so the value must not be longer than specified in `Arrow.MAX_ARROW_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `arrowName` - Name of an existing outgoing arrow on this node.
    `votingRuleType` - The type of voting rule. Use the integer constant of `VotingRule`.
    `threshold` - Threshold for this voting rule.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called. Further cases of throwing this exception are: This node does not support voting or the supplied arrow name is invalid or null.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportVoting()`, `getVotingRule(String)`, `getVotingRules()`, `VotingRule`, `Arrow`

### getVotingRule

    public VotingRule getVotingRule(java.lang.String arrowName)
                             throws ModelException

  Returns the current voting rule of a specified outgoing arrow of this node as defined in the `VotingRule` interface by constants such as `VotingRule.TYPE_MAJORITY`.

  The name of arrow is a link to a `Arrow` object, so the value must not be longer than specified in `Arrow.MAX_ARROW_NAME_LENGTH`.

  Returns an empty `VotingRule` object if no voting rule is defined for the supplied arrow name.

  Note, that this functionality is only supported for voting nodes (`TYPE_VOTING_ACTIVITY).`

  Parameters:
    `arrowName` - Name of the outgoing arrow to get the voting rule for.
  Returns:
    The `VotingRule` object which specifies the current voting rule of the outgoing arrow of this node.
  Throws:
    `ModelException` - When this node does not support voting or the supplied arrow name does not exist.
  See Also:
    `supportVoting()`, `setVotingRule(String, int, int)`

### getVotingRules

    public VotingRule[] getVotingRules()
                                throws ModelException

  Returns the complete list of defined voting rules for the outgoing arrows of this node.

  If no voting rules are defined, this method returns an array of empty `VotingRule` objects for each outgoing arrow.

  Note, that this functionality is only supported for voting nodes (`TYPE_VOTING_ACTIVITY).`

  Returns:
    A list of defined voting rules for this node.
  Throws:
    `ModelException` - When this node does not support voting.
  See Also:
    `supportVoting()`, `setVotingRule(String, int, int)`

### setEvaluationOrder

    public void setEvaluationOrder(java.lang.String[] arrowNames)
                            throws ModelException

  Specifies the order of evaluation for arrrows outgoing from this node. Note that this operation is only supported for voting nodes.

  The names contains in the array are links to `Arrow` objects, so they must not be longer than specified in `Arrow.MAX_ARROW_NAME_LENGTH`.

  Depending on the component this node belongs to, edit-mode of process definition or structural edit-mode of process instance is required. Edit-mode of process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  Parameters:
    `arrowNames` - List of outgoing arrow names regarding to this node, in the order of evaluation.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when calling this method, or when the supplied arrowNames are invalid or null. Furthermore an exception is thrown when this node does not support voting.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `supportVoting()`, `getEvaluationOrder()`

### getEvaluationOrder

    public java.lang.String[] getEvaluationOrder()
                                          throws ModelException

  Returns the arrow names of this node in the order of evaluation.

  If no outgoing arrows exist for this node, an empty array is returned. Otherwise the outgoing arrows are returned in the added order, if no evaluation order was defined before.

  Note, that this functionality is only supported for nodes that allow voting.

  Returns:
    The names of outgoing arrows regarding to this node in the order of evaluation.
  Throws:
    `ModelException` - Thrown when this node does not support voting.
  See Also:
    `supportVoting()`, `setEvaluationOrder(String[])`

### getCustomNodeType

    public java.lang.String getCustomNodeType()
                                       throws ModelInternalException

  Returns the custom node type of this node. With custom nodes, any node can have a custom UI presentation while it is still based on one of the standard node types.

  Custom nodes are uniquely identified by the fully qualified class name that implements their UI.

  Returns `null` if no custom node type is defined.

  Returns:
    The fully qualified class name of the custom node type or `null` if this node has no custom node type specified.
  Throws:
    `ModelInternalException`
  See Also:
    `isCustomNodeType()`, `setCustomNodeType(String)`

### isCustomNodeType

    public boolean isCustomNodeType()

  Returns `true` if this node is a custom node.

  Returns:
    `true` if this node is a customer node; `false` otherwise.

### setCustomNodeType

    public void setCustomNodeType(java.lang.String CustomNodeType)
                           throws ModelInternalException

  Set the custom node type identifier for this node. With custom nodes, any node can have a custom UI presentation while it is still based upon one of the standard node types. Custom nodes are uniquely identified by the fully qualified class name that implements their UI.

  The `CustomerNodeType` is limited to the number of characters specified by `MAX_CUSTOM_NODE_TYPE_LENGTH`.

  Parameters:
    `CustomNodeType` - The fully qualified class name of the custom node type.
  Throws:
    `ModelInternalException`
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`

### supportTrigger

    public boolean supportTrigger()

  Returns `true` if the node supports triggers. Not all nodes support triggers. This method allows you to determine if this node supports triggers or not.

  Returns:
    `true` if the node supports triggers; `false` otherwise.

### addTrigger

    public TriggerDef addTrigger(java.lang.String name,
                                 int type)
                          throws ModelException

  Adds a new trigger definition with the given name and type to this node. The name must not be longer than `TriggerDef.MAX_TRIGGER_NAME_LENGTH`. The type must be one of the types defined within the `TriggerDef` object, like `TriggerDef.START_PROCESS`.

  Depending on the component this node belongs to, edit-mode of the process definition or structural edit-mode of process instance is required. Edit-mode of a process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  This method is not supported if this node is fetched from the process instance.

  Parameters:
    `name` - The name of the trigger to be added.
    `type` - The type of the trigger to be added.
  Returns:
    The new trigger definition of the supplied type with the given name.
  Throws:
    `ModelException` - Thrown when this Node is fetched from the process instance or when the related process definition is not in edit mode. Furthermore this exception is thrown if the supplied name is invalid (e.g. the length of name is 0) or `null`.
  See Also:
    `Plan.startEdit()`

### getTrigger

    public TriggerDef getTrigger(long triggerId)
                          throws ModelException

  Returns the trigger definition for the supplied ID.

  Parameters:
    `triggerId` - The unique identifier of the trigger to be returned.
  Returns:
    The specified trigger definition.
  Throws:
    `ModelException` - Thrown when no trigger definition could be found for the specified ID.
  See Also:
    `addTrigger(String, int)`

### getTriggers

    public TriggerDef[] getTriggers()
                             throws ModelException

  Returns all trigger definitions associated with this node.

  Returns:
    The trigger definitions of this node.
  Throws:
    `ModelException`
  See Also:
    `addTrigger(String, int)`

### getTriggers

    public TriggerDef[] getTriggers(int type)
                             throws ModelException

  Returns all trigger definitions of this node that are of the specified type.

  Parameters:
    `type` - The type of the trigger definition. The type must be one of the constants defined within the `TriggerDef` object, like `TriggerDef.START_PROCESS`.
  Returns:
    An array of all the trigger definitions with the supplied type. Returns an empty array in case there are no trigger definitions of the specified type.
  Throws:
    `ModelException`

### removeTrigger

    public void removeTrigger(long triggerId)
                       throws ModelException

  Removes the specified trigger definition from this node.

  Depending on the component this node belongs to, edit-mode of the process definition or structural edit-mode of process instance is required. Edit-mode of a process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  This method is not supported if this node is fetched from the process instance.

  Parameters:
    `triggerId` - The unique identifier of the trigger to be removed.
  Throws:
    `ModelException` - Thrown when this Node is fetched from the process instance or when the process definition is not in edit-mode.
  See Also:
    `Plan.startEdit()`

### removeTriggers

    public void removeTriggers()
                        throws ModelException

  Removes all trigger definitions from this node.

  Depending on the component this node belongs to, edit-mode of the process definition or structural edit-mode of process instance is required. Edit-mode of a process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  This method is not supported if this node is fetched from the process instance.

  Throws:
    `ModelException` - Thrown when this Node is fetched from the process instance or when the related process definition is not in edit-mode.
  See Also:
    `Plan.startEdit()`

### setDueDateDef

    public TimerDef setDueDateDef(TimerDef dd)
                           throws ModelException

  Set the due date for this node. This is only supported if the type of this node is `TYPE_ACTIVITY` or `TYPE_VOTING_ACTIVITY`. If the due date for this node is already set, then it will be overwritten with the `TimerDef` passed in.

  Depending on the component this node belongs to, edit-mode of the process definition or structural edit-mode of process instance is required. Edit-mode of a process definition is entered by calling `Plan.startEdit`. Structural edit-mode is entered by calling `ProcessInstance.startStructuralEdit`.

  NOTE: This adds the timer defined by dd to this node. You should NOT call addTimer(xx) with the same timer definition.

  Parameters:
    `dd` - A `TimerDef` object describing the due date, or null if no due date is to be defined for this activity.
  Returns:
    The new added `TimerDef` object.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called.
  See Also:
    `Plan.startEdit()`, `ProcessInstance.startStructuralEdit()`, `TYPE_ACTIVITY`, `TYPE_VOTING_ACTIVITY`

### getDueDateDef

    public TimerDef getDueDateDef()
                           throws ModelException

  Returns the due date for this node. This is only supported if the type of this node is `TYPE_ACTIVITY` or `TYPE_VOTING_ACTIVITY`.

  Returns `null` if no due date is defined.

  Returns:
    A `TimerDef` object describing the due date definition, or null if no due date has been set for this node.
  Throws:
    `ModelException`

### getExtendedAttributes

    public org.w3c.dom.Document getExtendedAttributes()
                                               throws ModelException

  Returns the DOM document that contains all extended attributes of this node. Extended attributes are used to store customization information. The term "Extended Attributes" comes from the XPDL standard specification which uses this term to mean extra information that is not part of the standard. We use it here in a similar but not precisely the same way. Here it means 'extra information that is not native the product'. There are four different categories of information which could be associated with a node:
  - Category 1: known to the XPDL spec, and native to Interstage BPM. This category will never be in extended attributes. In this case XPDL and Interstage BPM 'agree' and the information is mapped back and forth without needing extended attributes.
  - Category 2: unknown to XPDL, but native to Interstage BPM. This information is encoded by Interstage BPM into extended attributes in the XPDL file when written, and when the XPDL file is read, the extended attributes are encoded back into native Interstage BPM quantities. An example of this is X & Y coordinates which are part of this API, but not a native part of XPDL 1.0, so that extended attributes would have to be used. Those extended attributes appear in the XPDL file, but do not appear here because there are other API calls to retrieve them.
  - Category 3: unknown to XPDL, and unknown to Interstage BMN. This might be extended attributes that were added to the XPDL by a foreign process product. Proper handling of XPDL requires that these values be preserved and included in the process if it is ever written out to XPDL again. These are the extended attributes that you will find represented here as well as in the XPDL file. In some cases, our own BPM clients may understand and make use of this information, so this become a general purpose extension mechanism that special purpose clients can make use of to store meta-data about the process definition, and have some assurance that it will be preserved through XPDL.
  - Category 4: known to XPDL, but not native to Interstage BPM. Theoretically, there could be information that is required to be preserved as part of an XPDL file, which is not native to BPM, and this information could be preserved using this extended attribute mechanism. Therefor it is possible that there could be additional extended attributes from this API that would not be present in the XPDL as extended attributes, but at the time of this writing there were no cases of this.
  The schema for the extended attributes is:

       <xsd:element name="ExtendedAttributes">
          <xsd:complexType>
             <xsd:sequence>
                <xsd:element ref="xpdl:ExtendedAttribute" minOccurs="0" maxOccurs="unbounded"/>
             </xsd:sequence>
          </xsd:complexType>
       </xsd:element>

       <xsd:element name="ExtendedAttribute">
          <xsd:complexType mixed="true">
             <xsd:choice minOccurs="0" maxOccurs="unbounded">
                <xsd:any minOccurs="0" maxOccurs="unbounded"/>
             </xsd:choice>
             <xsd:attribute name="Name" type="xsd:NMTOKEN" use="required"/>
             <xsd:attribute name="Value" type="xsd:string"/>
          </xsd:complexType>
       </xsd:element>

  A complete example with three extended attributes:

       <ExtendedAttributes>
          <ExtendedAttribute Name="DataRef-ParticipantID-1" Value="ID_CSE"/>
          <ExtendedAttribute Name="XOffset" Value="400"/>
          <ExtendedAttribute Name="YOffset" Value="140"/>
       </ExtendedAttributes>

  This operation is only supported on the node definition level. It is not possible to get the extended attributes from an instance of a node.

  Returns:
    The DOM document that contains all of the node level extended attributes.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called.
    `ModelException` - Thrown when this operation is called from a `NodeInstance`
  See Also:
    `setExtendedAttributes(Document)`

### setExtendedAttributes

    public void setExtendedAttributes(org.w3c.dom.Document attrs)
                               throws ModelException

  Sets the extended attributes of this node, contained in the supplied DOM document. Extended attributes are used to store customization information. See `Node.getExtendedAttributes` for details.

  This operation is only supported on the node definition level. It is not possible to set the extended attributes to an instance of a node.

  Edit-mode of the process definition is required. Edit-mode is entered by calling `Plan.startEdit`.

  Parameters:
    `attrs` - The DOM document that contains all of the node level extended attributes.
  Throws:
    `ModelException` - Thrown when the process definition is not in edit-mode when this method is called.
    `ModelException` - Thrown when this operation is called on a `NodeInstance`.
  See Also:
    `Plan.startEdit()`, `getExtendedAttributes()`

### getUpperLeftPoint

    public java.awt.Point getUpperLeftPoint()
                                     throws ModelException

  Returns the upper left point of this node.

  Returns:
    A java.awt.Point object describing location of the upper left corner.
  Throws:
    `ModelException`

### setUpperLeftPoint

    public void setUpperLeftPoint(java.awt.Point point)
                           throws ModelException

  Sets the upper left point into this node.

  Parameters:
    `point` - The location of the upper left corner.
  Throws:
    `ModelException`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD