StateSimple.Trans

java.lang.Object
- org.vishia.states.StateSimple.Trans

Direct Known Subclasses:

StateSimple.Timeout, StateSimple.TransChoice, StateSimple.TransJoin

Enclosing class:

StateSimple
```
public class StateSimple.Trans
extends java.lang.Object
```
An instance of this class represents a transition of the enclosing SimpleState to one or more destination states. The application should build an instance of Trans maybe as derived anonymous classes of StateSimple.Trans for each transition, which should be initialized with the destination state classes.
```
   class MyState_A extends StateSimple
   {
      Trans cause_State1 = new Trans(MyState1.class);
   
      Trans trans1_State2 = new Trans(MyState_B.class) {
        (at)Override void action(EventObject ev) {
          ...any action
        } 
     }; 
 
```
The method action(EventObject) in the transition instance is optional. The state should override the method StateSimple.checkTrans(EventObject) which contains the check of all transition conditions except for given StateSimple.Timeout and StateSimple.TransJoin. That transitions are selected without user code only because they are existing as instances.

The method buildTransitionPath() is invoked only on startup of the statemachine. It creates the exitStates and entryStates -list.

How does it works:
- The derived Trans class or the element of type Trans will be detected by checking the State class content via reflection.
- The transition instance is stored in the private StateSimple.aTransitions array.
- The entry and exit states are completed.

Field Summary

Fields
Modifier and Type	Field and Description
`protected StateAction`	`action` If an action is given, the condition should not contain an action itself.
`protected StateSimple.Trans[]`	`choice` More as one choice can be given if this transition is a choice-transition.
`(package private) boolean`	`doneAction` Set it to false on start of check this transition.
`(package private) boolean`	`doneEntry` Set it to false on start of check this transition.
`(package private) boolean`	`doneExit` Set it to false on start of check this transition.
`(package private) int[]`	`dst` All destination classes from constructor.
`(package private) StateSimple[]`	`entryStates` All states which's `StateSimple#entry(EventMsg2)` have to be processed if the transition is fired.
`(package private) StateSimple[]`	`exitStates` All states which's `StateSimple#exitTheState()` have to be processed if the transition is fired.
`(package private) int`	`ixCommonInStatePath` Index of the common state for this transition in the `StateSimple.statePath` of any source state.
`(package private) StateSimple.Trans`	`parent` It is null for a simple transition in a state.
`int`	`retTrans` Return value of the last used transition test.
`(package private) java.lang.String`	`transId` Identification String for the transition, for debug.

Constructor Summary

Constructors
Constructor and Description
`Trans(java.lang.Class<?>... dst)` This constructor is used to initialize a Transition instance maybe for a derived anonymous class with null, one or more destination state of this transition or as super constructor for derived classes if a priority should be given.
`Trans(java.lang.String name, int[] dstKeys)` This constructor should be used if the destination states are given from an outer algorithm.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`action(java.util.EventObject ev)` The non-overridden action executes the `action` or returns 0 if it is not given.
`(package private) void`	`buildTransitionPath()` Builds the transition path from given state to all dst states.
`(package private) void`	`doAction(java.util.EventObject ev, int recurs)` Processes the action of the transition.
`void`	`doEntry(java.util.EventObject ev)` Entry in all states for this transition maybe with history entry.
`void`	`doExit()` Executes the exit from this state and all enclosing States to fire the transition.
`StateSimple.Trans`	`eventConsumed()` Set the state of transition execution to `EventConsumer.mEventConsumed` and return this.
`void`	`setAction(StateAction action)` Sets the action to this transition.
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - retTrans
```
public int retTrans
```
    Return value of the last used transition test. For debugging and for the TransitionMethod.
  - dst
```
final int[] dst
```
    All destination classes from constructor. They are not necessary furthermore after buildTransitionPath() because they are processed in the exitStates and entryStates lists.
  - action
```
protected StateAction action
```
    If an action is given, the condition should not contain an action itself. The action is executed after the exitState()-operation and before the entryState()-operation.
    
    The action can be given by any StateAction instance in any other class. It can be set by construction.
  - choice
```
protected StateSimple.Trans[] choice
```
    More as one choice can be given if this transition is a choice-transition. The transition is only fired if at least one choice-condition is true. The action of the state and the action of the choice is executed one after another after exit() and before entry() only if the transition is fired. If some choice are given, the choice should contain the destination state. The constructor of this transition have to be empty.
  - parent
```
StateSimple.Trans parent
```
    It is null for a simple transition in a state. It contains the parent transition for a choice, which is an inner transition.
  - exitStates
```
StateSimple[] exitStates
```
    All states which's StateSimple#exitTheState() have to be processed if the transition is fired.
  - ixCommonInStatePath
```
int ixCommonInStatePath
```
    Index of the common state for this transition in the StateSimple.statePath of any source state. It is used to execute the exit() of all nested source states.
  - entryStates
```
StateSimple[] entryStates
```
    All states which's StateSimple#entry(EventMsg2) have to be processed if the transition is fired. The array is filled by reflection in the constructor of the state class. There the private Trans.BuildTransitionPath#buildEntryStates() is invoked to fill the array. On doneEntry the states in this array are entered. For a simple transition the content of this array is simple, the order of the entry states from the last exitStates. For a fork transition to parallel states this array contains all entered states as a parallel fork. See an example:
    
    Example for 3 branches of a fork:
```
    statePath  statePath  statePath
 --+---------+----------+----------   
 0  topState   topState   topState
 1  StateC     StateC     StateC     
 1  StateAp    StateAp    StateAp     StateAp is a StateParallel
 2  StateA1    StateBp    StateBp     StateBp is a StateParallel
 3  StateA11   StateB1    StateB2
 4             StateB12   StateB25
 5                        StateB252
 
```
    The common state may be the StateC because the transition goes from a State inside stateC to the shown 3 destination states. Therefore the #ixInStatePath is initialized with [2, 2, 2].
    - [2]: Now the algorithm enteres stateC found at statePath[2] but only one time because it is the same for all state paths.
    - [3]: stateA1 is entered. After them StateBp but only one time because it is the same twice.
    - [4]: stateA11, then StateB1, then StateB2 is entered.
    - [5]: Because the first statePath is ended, nothing is done for that. Then StateB12 and StateB25 is entered.
    - [6]: At last StateB525 is entered.
    Another presentation shows:
```
  0     1        2           3          4      5      6  ix in statePath
            +<---Cxy
            |        
 top--->C   +--->Ap --->|--->A1
                        |
                        |--->Bp--->|--->B1--->B12
                                   |--->B2--->B25--->B251
 
```
    Cxy may be the exit state, C is the common state. The array contains:
```
 Ap, A1, Bp, B1, B2, B12, B25, B251
 
```
  - transId
```
java.lang.String transId
```
    Identification String for the transition, for debug.
  - doneExit
```
boolean doneExit
```
    Set it to false on start of check this transition. The methods #doEntry(EventMsg2), #doAction(Trans, EventMsg2, int) and doExit() sets it to true. If a #check(EventMsg2) method has not invoked this methods, they are invoked from the StateSimple#_checkTransitions(EventMsg2).
  - doneAction
```
boolean doneAction
```
    Set it to false on start of check this transition. The methods #doEntry(EventMsg2), #doAction(Trans, EventMsg2, int) and doExit() sets it to true. If a #check(EventMsg2) method has not invoked this methods, they are invoked from the StateSimple#_checkTransitions(EventMsg2).
  - doneEntry
```
boolean doneEntry
```
    Set it to false on start of check this transition. The methods #doEntry(EventMsg2), #doAction(Trans, EventMsg2, int) and doExit() sets it to true. If a #check(EventMsg2) method has not invoked this methods, they are invoked from the StateSimple#_checkTransitions(EventMsg2).
- Constructor Detail
  - Trans
```
public Trans(java.lang.Class<?>... dst)
```
    This constructor is used to initialize a Transition instance maybe for a derived anonymous class with null, one or more destination state of this transition or as super constructor for derived classes if a priority should be given. All transitions without priority are lower. This constructor should not be used if a transition class contains choice-transitions.
    
    Parameters:
    
    dst - null, one ore more destination classes. If the dst is null or not given, the transition is a inner-state-transition. If it fires the StateSimple.exit() and the entry is not executed. If more as one dst is given this is a fork transition to more as one state, which should be states in parallel composite states.
  - Trans
```
public Trans(java.lang.String name,
             int[] dstKeys)
```
    This constructor should be used if the destination states are given from an outer algorithm.
    
    Parameters:
    
    dstKeys -
- Method Detail
  - setAction
```
public void setAction(StateAction action)
```
    Sets the action to this transition. The action can be implemented in any other class of the application as inner nonstatic class and can be accessed to the data to its environment class. That is the advantage in comparison to a overridden method action(EventObject). This action is used only if the method action is not overridden.
    
    Parameters:
    
    action -
  - eventConsumed
```
public StateSimple.Trans eventConsumed()
```
    Set the state of transition execution to EventConsumer.mEventConsumed and return this. This method should be used in StateSimple.checkTrans(EventObject) if an event is the trigger:
```
  QOverride public Trans selectTransition(EventObject ev) {
   if(ev == expectedEv) return myTrans.eventConsumed();
   ...
 
```
  - buildTransitionPath
```
void buildTransitionPath()
```
    Builds the transition path from given state to all dst states. Called on startup.
  - action
```
protected void action(java.util.EventObject ev)
```
    The non-overridden action executes the action or returns 0 if it is not given.
    
    Parameters:
    
    ev - event
  - doAction
```
final void doAction(java.util.EventObject ev,
                    int recurs)
```
    Processes the action of the transition. If it is a choice transition: firstly process the action of the condition before. It is calling recursively for more as one choice.
    
    Parameters:
    
    parent - The transition before this choice or null on State-transition
    
    ev - The given event.
    
    recurs - recursion count. throws IllegalArgumentException if > 20
  - doExit
```
public final void doExit()
```
    Executes the exit from this state and all enclosing States to fire the transition. Because this state may be a StateCompositeFlat the StateComposite.stateAct of its StateSimple.compositeState() will be used to invoke StateSimple.exitTheState(int) always.
  - doEntry
```
public final void doEntry(java.util.EventObject ev)
```
    Entry in all states for this transition maybe with history entry. This method can be invoked inside an application-specific StateSimple.checkTrans(EventObject) routine with the selected transition. The routine sets the flag doneEntry. If the method is not invoked by the application it will be invoked in the StateSimple._checkTransitions(EventObject). The states will be entered in the order from outer to inner state and for all parallel states then from outer to inner one in each parallel both, using the entryStates. It regards history entry: StateDeepHistory, StateShallowHistory.
    
    Parameters:
    
    ev - The data of the event can be used by entry actions.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class StateSimple.Trans

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

retTrans

dst

action

choice

parent

exitStates

ixCommonInStatePath

entryStates

transId

doneExit

doneAction

doneEntry

Constructor Detail

Trans

Trans

Method Detail

setAction

eventConsumed

buildTransitionPath

action

doAction

doExit

doEntry

toString