States.
@see State
@author bob mcwhirter
A transition, which belongs to a source state, consists of a Unicode character interval and a destination state. @author Anders Møller <amoeller@cs.au.dk>
Condition) repräsentiert. Um die Bedingung festzulegen, wird über den Konstruktor oder über die set-Methode die Bedingung als String übergeben und automatisch in die benötigte Datenstruktur übersetzt.
@author Lukas König
Condition) repr�sentiert. Um die Bedingung festzulegen, wird �ber den Konstruktor oder �ber die set-Methode die Bedingung als String �bergeben und automatisch in die ben�tigte Datenstruktur �bersetzt.
@author Lukas K�nig
The following features are supported:
This is a one way link. It emanates from a state (usually via a list of transitions) and has a target state.
Since we never have to change the ATN transitions once we construct it, we can fix these transitions as specific classes. The DFA transitions on the other hand need to update the labels as it adds transitions to the states. We'll use the term Edge for the DFA to distinguish them from ATN transitions.
A transition describes the switching of a workflow instance from one state to another. A transition has
Additionally, a transition can be marked as synchronized.
A transition, which belongs to a source state, consists of a Unicode codepoint interval and a destination state. @lucene.experimental
Description of a transition from the owning {@link State} to another{@link State} with a specified identifier. {@link Transition} instancesare owned by a single {@link State} instance, or are global to an entire{@link Dialog} instance, and during execution of an application they areimmutable.
@since 1.0.4TODO
A wait condition indicates wether a transition is to be taken synchronously or wether the transition will behave as a wait state.
Transitions that are wait states can occur when an analyst has an actual state (e.g. 'making loss') and a desired state (e.g. 'making profit') and models a transition between those states. In that case the transition might take a long time and hence it results into a wait state for the system.
If the wait condition is null or if it returns false, then the transition will be taking synchronously. Otherwise the transition will behave as a wait state and wait for a signal on the execution.
Transitions as wait states has every thing to do with matching the process graph to transactions on the server. If the transition is taken in one (the current) transaction, then the async condition should be empty or evaluate to false. If the arrival of the execution in the destination activity should occur in a separate execution @author Tom Baeyens
When executed a transition takes a flow execution from its current state, called the source state, to another state, called the target state. A transition may become eligible for execution on the occurrence of an {@link Event} from within a transitionable source state.
When an event occurs within this transition's source TransitionableState the determination of the eligibility of this transition is made by a TransitionCriteria object called the matching criteria. If the matching criteria returns true this transition is marked eligible for execution for that event.
Determination as to whether an eligible transition should be allowed to execute is made by a TransitionCriteria object called the execution criteria. If the execution criteria test fails this transition will roll back and reenter its source state. If the execution criteria test succeeds this transition will execute and take the flow to the transition's target state.
The target state of this transition is typically specified at configuration time in a static manner. If the target state of this transition needs to be calculated in a dynamic fashion at runtime configure a {@link TargetStateResolver} that supports such calculations. @see TransitionableState @see TransitionCriteria @see TargetStateResolver @author Keith Donald @author Erwin Vervaet
A transition can contain actions. The way to specify actions is to give value to the outputActions parameter and the setActions parameter. The value of these parameters is a string of the form:
command; command; ...where each command has the form:
destination = expressionFor the outputActions parameter, destination is either
portNameor
portName(channelNumber)Here, portName is the name of a port of the FSM actor, If no channelNumber is given, then the value is broadcasted to all channels of the port.
For the setActions parameter, destination is
variableNamevariableName identifies either a variable or parameter of the FSM actor, or a variable or parameter of the refinement of the destination state of the transition. To give a variable of the refinement, use a dotted name, as follows:
refinementName.variableNameThe expression is a string giving an expression in the usual Ptolemy II expression language. The expression may include references to variables and parameters contained by the FSM actor.
The outputActions and setActions parameters are not the only ways to specify actions. In fact, you can add action attributes that are instances of anything that inherits from Action. (Use the Add button in the Edit Parameters dialog).
An action is either a ChoiceAction or a CommitAction. The setActions parameter is a CommitAction, whereas the outputActions parameter is a ChoiceAction. A commit action is executed when the transition is taken to change the state of the FSM, in the postfire() method of FSMActor. A choice action, by contrast, is executed in the fire() method of the FSMActor when the transition is chosen, but not yet taken. The difference is subtle, and for most domains, irrelevant. A few domains, however, such as CT, which have fixed point semantics, where the fire() method may be invoked several times before the transition is taken (committed). For such domains, it is useful to have actions that fulfill the ChoiceAction interface. Such actions participate in the search for a fixed point, but do not change the state of the FSM.
A transition can be preemptive or non-preemptive. When a preemptive transition is chosen, the refinement of its source state is not fired. A non-preemptive transition is only chosen after the refinement of its source state is fired.
The reset parameter specifies whether the refinement of the destination state is reset when the transition is taken. There is no reset() method in the Actor interface, so the initialize() method of the refinement is called. Please note that this feature is still under development.
The nondeterministic parameter specifies whether this transition is nondeterministic. Here nondeterministic means that this transition may not be the only enabled transition at a time. The default value is a boolean token with value as false, meaning that if this transition is enabled, it must be the only enabled transition.
The defaultTransition parameter, if given a value true, specifies that this transition is enabled if and only if no other non-default transition is enabled. @author Xiaojun Liu, Edward A. Lee, Haiyang Zheng @version $Id: Transition.java,v 1.115 2007/12/07 06:27:40 cxh Exp $ @since Ptolemy II 0.4 @Pt.ProposedRating Yellow (hyzheng) @Pt.AcceptedRating Red (hyzheng) @see State @see Action @see ChoiceAction @see CommitAction @see CommitActionsAttribute @see FSMActor @see OutputActionsAttribute
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |