StateSimple

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

All Implemented Interfaces:

InfoAppend

Direct Known Subclasses:

StateCompositeFlat, StateDeepHistory, StateParallel, StateShallowHistory
```
public abstract class StateSimple
extends java.lang.Object
implements InfoAppend
```
Base class of a State in a State machine. It is the super class of StateComposite too. The user should build states in a StateMachine by writing derived classes of this class or of StateComposite which contains transitions and may override the #entry(EventMsg2) and exit() method:
```
 class MyStateMachine extends StateMachine
 {
   class StateA extends StateSimple  //one  state
   {
     (add)Override protected int entry(Event ev) { ...code of entry... } 
     (add)Override protected void exit() { ...code of exit... }
     
     //Form of a transition as method which is detected by reflection:
     Trans checkX_DstState(Event ev, Trans trans){
          if(trans == null){
            return new Trans(DstState.class);   //called on startup, programmed the destination state(s)
          }  
          else if(...condition...) {            //Check any condition
            trans.retTrans =  mEventConsumed;  //if an event is used as condition
            trans.doExit();
            ...transition action code...
            trans.doEntry(ev);
            return trans;
          }
          else return null;
        }
      
        //Form of a transition as instance of an derived anonymous class:
        Trans checkY_StateY = new Trans(StateY.class) {
        
          (add)Override protected int check(Event ev) {  //overrides the trans method:
            if(...condition...) { 
              retTrans = mEventConsumed;
              doExit();
              ...transition action code...
              doEntry(ev);
              return retTrans;
            }
            else return 0;
          }
        } 
         
   }
 }
 
```
For building a StateComposite see there.
- A state can contains either transition methods with the shown arguments and StateSimple.Trans as return instance,
- or a transition instances as derived anonymous types of Trans
- or a class derived from Trans] without an instance. It is not shown in this example, see {@link Trans}.
The decision between this three forms maybe a topic of view in a browser tree of the program structure (Outline view on Eclipse).

How does it work:
On startup all of this kinds of transitions are detected by reflection and stored in the private array {@link #aTransitions}. On runtime the transitions are tested in the order of its priority. If any transition returns not 0 or null they do fire. Either the {@link Trans#doExit()}, {@link Trans#doAction(EventObject, int)} and {@link Trans#doEntry(EventMsg2, int)} is programmed in the if-branch of the condition before return, or that methods are executed from the state execution process automatically. Manual programmed - it can be tested (step-debugger) in the users programm. Not manually, therefore automatically executed - one should set a breakpoint in the user-overridden {@link #exit()}, {@link #entry(EventMsg2)} or {@link Trans#action(EventMsg2)} methods or the debugging step should be done over the package private method {@link #_checkTransitions(EventMsg2)} of this class. Note that there are private boolean variables {@link Trans#doneExit}, {@link Trans#doneAction} and {@link Trans#doneEntry} to detect whether that methods are executed already.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`class`	`StateSimple.PlugStateSimpleToGenState` This class is used especially in `org.vishia.stateMGen.StateMGen` in the component srcJava_Zbnf to help generate a state machine for C language.
`class`	`StateSimple.Timeout` If a state contains a field of this class, a timeout is given for that state.
`class`	`StateSimple.Trans` An instance of this class represents a transition of the enclosing SimpleState to one or more destination states.
`class`	`StateSimple.TransChoice`
`class`	`StateSimple.TransJoin`

Field Summary

Fields
Modifier and Type	Field and Description
`private StateSimple.Trans[]`	`aTransitions` This array contains all transitions to handle it commonly.
`private java.lang.Object`	`auxInfo` Any additional information.
`protected StateComposite`	`compositeState` The state which is the composite state for this.
`int`	`ctEntry` Debug helper.
`long`	`dateLastEntry` Debug helper.
`long`	`durationLast` Debug helper.
`protected StateSimple`	`enclState` Reference to the enclosing state.
`protected StateAction`	`entry` Action for entry and exit.
`(package private) TimeOrder`	`evTimeout` The timeout event for this state stored also in the top state or a `StateParallel`.
`protected java.lang.Runnable`	`exit`
`protected int`	`ixCompositeState_inStatePath`
`static int`	`mEventConsumed` Bit in return value of a Statemachine's `#_checkTransitions(EventMsg2)` or entry method for designation, that the given Event object was used to switch.
`static int`	`mEventDonotRelinquish` Bit in return value of the `processEvent(EventObject)` for designation, that the given Event object is stored in another queue, therefore it should not relinquished yet.
`static int`	`mEventNotConsumed` Use this designation for `StateSimple.Trans.retTrans` to signal that an event is not consumed in `checkTrans(EventObject)`.
`(package private) int`	`millisectimeout` If set, on state entry the timer for timeout is set.
`protected int`	`modeTrans` It is either 0 or `mRunToComplete`.
`static int`	`mRunToComplete` Bit in return value of a Statemachine's trans and entry method for designation, that the given State has non-event-driven transitions, therefore the trans method should be called in the same cycle.
`static int`	`mStateEntered` Bit in return value of a Statemachine's trans and entry method for designation, that the given State has entered yet.
`static int`	`mStateLeaved` If a composite state is leaved, any other parallel composite states don't processed then.
`static int`	`mTransit` Bit in return value of a Statemachine's trans method for designation, that the given Transition is true.
`static int`	`notTransit` Specification of the consumed Bit in return value of a Statemachine's `#_checkTransitions(EventMsg2)` or `#entry(int)` method for designation, that the given Event object was not used to switch.
`protected java.lang.String`	`stateId` The own identification of the state.
`protected StateMachine`	`stateMachine` Aggregation to the whole state machine.
`protected StateSimple[]`	`statePath` Path to this state from the top state.
`(package private) StateSimple.Timeout`	`transTimeout` A timeout transition created in the application.
`static java.lang.String`	`version` Version, history and license.

Constructor Summary

Constructors
Modifier Constructor and Description

protected StateSimple()

Constructors
Modifier	Constructor and Description
`protected`	`StateSimple()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`(package private) int`	`_checkTransitions(java.util.EventObject ev)` Check all transitions and fire one transition if true.
`java.lang.Object`	`auxInfo()` Gets the auxiliary information to that state which is set with `setAuxInfo(Object)`.
`(package private) void`	`buildStatePath(StateSimple enclState)` Sets the path to the state for this and all `#aSubstates`, recursively call.
`(package private) void`	`buildStatePathSubstates(StateSimple enclState, int recurs)` It is overridden package-local in all derived `StateComposite`, `StateParallel`.
`protected StateSimple.Trans`	`checkTrans(java.util.EventObject ev)` This method should be overridden by the user to select a transition which should be fire with given conditions.
`StateComposite`	`compositeState()` Returns that state which is the composite state which controls the activity of that independent part of the StateMachine.
`(package private) void`	`createTransitionList(java.lang.Object stateInstance, StateSimple.Trans parent, int nRecurs)` Creates the list of all transitions for this state, invoked one time after constructing the statemachine.
`(package private) void`	`createTransitionListSubstate(int recurs)` Create all transition list for this state and all `#aSubstates`, recursively call.
`StateSimple`	`enclState()` Returns that state which is the enclosing state.
`protected int`	`entry(java.util.EventObject ev)` This method may be overridden for a entry action.
`(package private) int`	`entryTheState(java.util.EventObject ev, boolean history)` Executes enter in this state.
`protected void`	`exit()` This method may be overridden for a exit action.
`protected void`	`exitTheState(int level)` Exits the state and all enclosing states till level.
`java.lang.String`	`getName()` Returns the name of the state, for debugging.
`(package private) java.lang.CharSequence`	`getStatePath()` Gets the path to this state.
`java.lang.CharSequence`	`infoAppend(java.lang.StringBuilder u)` Appends or returns tan information about the instance.
`boolean`	`isInState()` Check and returns true if the enclosing state has this state as active one.
`protected boolean`	`isTimeout(java.util.EventObject ev)` Checks whether the given event is the timeout event for this state.
`private void`	`prepareTransition(StateSimple.Trans trans, int nRecurs)`
`(package private) void`	`prepareTransitions(StateSimple.Trans parent, int nRecurs)` Prepares all transitions.
`(package private) void`	`prepareTransitionsSubstate(int recurs)` Prepare the own transitions.
`private void`	`printTransInfo(StateSimple.Trans trans, java.util.EventObject ev)`
`(package private) int`	`processEvent(java.util.EventObject ev)` Applies an event to this state respectively processes the event with this state.
`void`	`setAuxInfo(java.lang.Object info)` Sets any auxiliary information to that state.
`void`	`setEntryAction(StateAction entry)` Sets the entry-action for this state.
`void`	`setExitAction(java.lang.Runnable exit)` Sets the exit-action for this state.
`StateSimple[]`	`statePath()` Returns the path of all states from the top state in the hierarchie of this state.
`java.lang.String`	`toString()` Returns the state Id and maybe some more debug information.

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

- Field Detail
  - version
```
public static final java.lang.String version
```
    Version, history and license.
    - 2015-12-20 Hartmut chg: The deprecated possibilities of definition of methods for transition and check inside Trans are removed yet. It was an concept which has not proven.
    - 2015-12-20 Hartmut chg: exit: There were some mistakes: If a enclosing state transition was used to exit an inner state, its exit routine was not invoked, only that from the enclosing state. The strategy is changed: The StateSimple.Trans.exitStates is not used anymore, instead the StateComposite.stateAct is taken with the statePath() to invoke the correct exit routines. See exitTheState(int).
    - 2015-12-20 Hartmut chg: _checkTransitions(EventObject) now checks the transition from all enclosing but not composite states, that are StateCompositeFlat. That was done before in the StateComposite.processEvent(EventObject) routine but in a more difficult algorithm. Now for debugging it is more simple. The own checkTrans(EventObject) is invoked firstly. If not transition is found, the checkTrans(EventObject) of all enclosing states till a StateComposite are tested. The transitions of an enclosing StateComposite are checked in thats StateComposite.processEvent(EventObject) routine which calls this _checkTransitions(EventObject).
    - 2015-12-20 Hartmut chg: The timeout should be queried in the user's checkTrans(EventObject) routine. The automatic check is removed. Reason: A timeout event is disturbing often for debug. If it cannot be detect or prevented simply, it is adversarial. It is better to have the timeout handling in the same routine like all other transition conditions. The isTimeout(EventObject) routine helps to write simple code for that.
    - 2015-12-20 Hartmut chg: Now entry- and exit outputs with StateMachine.debugEntryExit.
    - 2015-11-21 Hartmut chg: The history pseudo state runs yet. Some problems.
    - 2015-02-10 Hartmut chg: A StateSimple.TransJoin have to be quest in the checkTrans(EventObject) routine. The transition after the join bar can have a condition or event trigger, which is to quest in the checkTrans. The automatically transition is removed, because it is not explicitly and cannot have conditions. Applications should be adapted.
    - 2014-11-09 Hartmut new: setAuxInfo(Object), auxInfo() used for state machine generation for C/C++
    - 2014-09-28 Hartmut chg: Copied from org.vishia.stateMachine.StateSimpleBase, changed concept: Nested writing of states, less code, using reflection for missing instances and data.
    - 2013-05-11 Hartmut chg: Override #exitAction() instead #exitTheState()!
    - 2013-04-27 Hartmut chg: The #entry(EventMsg2) and the #entryAction(EventMsg2) should get the event from the transition. It needs adaption in users code. The general advantage is: The entry action can use data from the event. A user algorithm does not need to process the events data only in the transition. A user code can be executed both in a special transition to a state and as entry action. Both possibilities do not distinguish in formal possibilities. The second advantage is: If the event is used, it should given to the next entry. If it is not used, a 'null' should be given. The user need not pay attention in the correct usage of mEventConsumed or not.
    - 2013-04-27 Hartmut new: mStateEntered is returned on any #entry(EventMsg2). If the state is not changed, a 'return 0;' should be written in the transition code. With the new bit especially the debugging can distinguish a state changed from a non-switching transition.
    - 2013-04-13 Hartmut re-engineering:
      
      The property whether or not there are non-event transitions is set on ctor. It is a property established in source code, therefore it should be known in runtime after construction already. The entry method does not need to modified because non-event transitions. It may be better because the entry method's code should not depend on the trans method's content.
      entry is final, it can be final now. For overwriting the #entryAction() is given. It is more simple to use.
      The trans method is protected: It should not be called from outside in any case.
    - 2013-04-07 Hartmut adapt: Event with 2 generic parameter
    - 2012-09-17 Hartmut improved.
    - 2012-08-30 Hartmut created. The experience with that concept are given since about 2001 in C-language and Java.
    Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:
    1. You can use this source without any restriction for any desired purpose.
    2. You can redistribute copies of this source to everybody.
    3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
    4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
    5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.
    If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.
    See Also:
    
    Constant Field Values
  - notTransit
```
public static final int notTransit
```
    Specification of the consumed Bit in return value of a Statemachine's #_checkTransitions(EventMsg2) or #entry(int) method for designation, that the given Event object was not used to switch. The value of this is 0.
    
    See Also:
    
    Constant Field Values
  - mEventConsumed
```
public static final int mEventConsumed
```
    Bit in return value of a Statemachine's #_checkTransitions(EventMsg2) or entry method for designation, that the given Event object was used to switch. It is 0x01.
    
    See Also:
    
    Constant Field Values
  - mEventDonotRelinquish
```
public static final int mEventDonotRelinquish
```
    Bit in return value of the processEvent(EventObject) for designation, that the given Event object is stored in another queue, therefore it should not relinquished yet. See EventConsumer.mEventDonotRelinquish
    
    See Also:
    
    Constant Field Values
  - mTransit
```
public static final int mTransit
```
    Bit in return value of a Statemachine's trans method for designation, that the given Transition is true. The bit should be set together with mEventConsumed if the event forces true. If this bit is set without mEventConsumed though an event is given the transition has not tested the event. In that case the event may be used in the following run-to-complete transitions.
    
    See Also:
    
    Constant Field Values
  - mStateEntered
```
public static final int mStateEntered
```
    Bit in return value of a Statemachine's trans and entry method for designation, that the given State has entered yet. If this bit is not set, an #entry(EventMsg2) action is not called. It means a state switch has not occurred. Used for debug.
    
    See Also:
    
    Constant Field Values
  - mStateLeaved
```
public static final int mStateLeaved
```
    If a composite state is leaved, any other parallel composite states don't processed then.
    
    See Also:
    
    Constant Field Values
  - mRunToComplete
```
public static final int mRunToComplete
```
    Bit in return value of a Statemachine's trans and entry method for designation, that the given State has non-event-driven transitions, therefore the trans method should be called in the same cycle.
    
    See Also:
    
    Constant Field Values
  - mEventNotConsumed
```
public static final int mEventNotConsumed
```
    Use this designation for StateSimple.Trans.retTrans to signal that an event is not consumed in checkTrans(EventObject).
    
    See Also:
    
    Constant Field Values
  - stateMachine
```
protected StateMachine stateMachine
```
    Aggregation to the whole state machine. Note: it cannot be final because it will be set on preparing only.
  - enclState
```
protected StateSimple enclState
```
    Reference to the enclosing state. With this, the structure of state nesting can be observed in data structures. The State knows its enclosing state to set and check the state identification there. Note: it cannot be final because it will be set on preparing only.
  - compositeState
```
protected StateComposite compositeState
```
    The state which is the composite state for this.
  - ixCompositeState_inStatePath
```
protected int ixCompositeState_inStatePath
```
  - auxInfo
```
private java.lang.Object auxInfo
```
    Any additional information. Used for special cases.
  - statePath
```
protected StateSimple[] statePath
```
    Path to this state from the top state. The element [0] is the top state. The last element is the enclosing state.
  - stateId
```
protected java.lang.String stateId
```
    The own identification of the state. Note: it cannot be final because it will be set on preparing only.
  - millisectimeout
```
int millisectimeout
```
    If set, on state entry the timer for timeout is set.
  - transTimeout
```
StateSimple.Timeout transTimeout
```
    A timeout transition created in the application.
  - evTimeout
```
TimeOrder evTimeout
```
    The timeout event for this state stored also in the top state or a StateParallel. This reference is null if this state has not a timeout transition. If this state is the top state or a StateParallel this refers the same instance for all states of this Composite. More as one parallel states have differen timeouts.
  - modeTrans
```
protected final int modeTrans
```
    It is either 0 or mRunToComplete. Or to the return value of entry.
  - ctEntry
```
public int ctEntry
```
    Debug helper. This counter counts any time on entry this state. Because it is public, the user can read it and reset it to 0 for some debug inventions. This variable should never be used for algorithm.
  - dateLastEntry
```
public long dateLastEntry
```
    Debug helper. This timstamp is set for System.currentTimeMilliSec() any time on entry this state. Because it is public, the user can read it for some debug inventions. This variable should never be used for algorithm.
  - durationLast
```
public long durationLast
```
    Debug helper. This time difference is set any time on exit this state. It is the time in milliseconds stayed in this state. Because it is public, the user can read it for some debug inventions. This variable should never be used for algorithm.
  - entry
```
protected StateAction entry
```
    Action for entry and exit. It can be set by the code block constructor in a derived class. Left empty if unused.
  - exit
```
protected java.lang.Runnable exit
```
  - aTransitions
```
private StateSimple.Trans[] aTransitions
```
    This array contains all transitions to handle it commonly. The transitions are given as instances in the derived classes from StateSimple in a Java written state machine. The transitions may be given with #addTransition(Trans) instead in a State machine which is parsed and translated for another language.
- Constructor Detail
  - StateSimple
```
protected StateSimple()
```
- Method Detail
  - setAuxInfo
```
public void setAuxInfo(java.lang.Object info)
```
    Sets any auxiliary information to that state. This method is used especially in org.vishia.stateMGen.StateMGen in the component srcJava_Zbnf to help generate a state machine for C language. But it can be used in the user's application in any way too.
    
    Parameters:
    
    info - Any object referred from this state.
  - auxInfo
```
public java.lang.Object auxInfo()
```
    Gets the auxiliary information to that state which is set with setAuxInfo(Object). This method is used especially in org.vishia.stateMGen.StateMGen in the component srcJava_Zbnf to help generate a state machine for C language. But it can be used in the user's application in any way too.
    
    Returns:
    
    Any object referred from this state.
  - statePath
```
public StateSimple[] statePath()
```
    Returns the path of all states from the top state in the hierarchie of this state. It may be used for debugging. It is used in StateMgen. Note: Do not change a state in the path! (Java does not know const keyword, rather than in C/C++)
  - compositeState
```
public StateComposite compositeState()
```
    Returns that state which is the composite state which controls the activity of that independent part of the StateMachine. Note: If a composite state is only used to build a pool of simple states which have common transition(s) the pool-building state is a StateCompositeFlat and it is not the rootState.
  - enclState
```
public StateSimple enclState()
```
    Returns that state which is the enclosing state. It may be equal to the compositeState(). Otherwise it may be a StateCompositeFlat or a StateParallel. Note: If a composite state is only used to build a pool of simple states which have common transition(s) the pool-building state is a StateCompositeFlat and it is not the compositeState().
  - setEntryAction
```
public void setEntryAction(StateAction entry)
```
    Sets the entry-action for this state. The entry-action can be implemented in any other class of the application as inner non static class and can be accessed to the data to its environment class. That is the advantage in comparison to a overridden method entry(EventObject). This action is used only if the method entry(EventObject) is not overridden.
    
    Parameters:
    
    action -
  - setExitAction
```
public void setExitAction(java.lang.Runnable exit)
```
    Sets the exit-action for this state. The exit-action can be implemented in any other class of the application as inner non static class and can be accessed to the data to its environment class. That is the advantage in comparison to a overridden method exit(). This action is used only if the method exit() is not overridden.
    
    Parameters:
    
    action -
  - isTimeout
```
protected boolean isTimeout(java.util.EventObject ev)
```
    Checks whether the given event is the timeout event for this state.
    
    Parameters:
    
    ev -
    
    Returns:
    
    true if this state has a timeout.
  - entry
```
protected int entry(java.util.EventObject ev)
```
    This method may be overridden for a entry action. In that case the entry or #entryMethod is either not used or it is used especially in the overridden method responsible to the user. If this method is not overridden, a given StateAction stored on entry is executed. That may be the execution of the #entryMethod.
    
    Parameters:
    
    ev - The data of the event can be used for the entry action.
    
    Returns:
    
    mRunToComplete if next states should be tested for conditions.
  - exit
```
protected void exit()
```
    This method may be overridden for a exit action. In that case the exit or #exitMethod is either not used or it is used especially in the overridden method responsible to the user. If this method is not overridden, a given Runnable stored on exit is executed. That may be the execution of the #exitMethod.
  - buildStatePathSubstates
```
void buildStatePathSubstates(StateSimple enclState,
                             int recurs)
```
    It is overridden package-local in all derived StateComposite, StateParallel.
    
    Parameters:
    
    enclState -
  - buildStatePath
```
final void buildStatePath(StateSimple enclState)
```
    Sets the path to the state for this and all #aSubstates, recursively call.
    
    Parameters:
    
    enclState -
    
    recurs -
  - createTransitionListSubstate
```
void createTransitionListSubstate(int recurs)
```
    Create all transition list for this state and all #aSubstates, recursively call. It is overridden package-local in all derived StateComposite, StateParallel.
    
    Parameters:
    
    recurs -
  - createTransitionList
```
void createTransitionList(java.lang.Object stateInstance,
                          StateSimple.Trans parent,
                          int nRecurs)
```
    Creates the list of all transitions for this state, invoked one time after constructing the statemachine.
  - prepareTransitionsSubstate
```
void prepareTransitionsSubstate(int recurs)
```
    Prepare the own transitions. This method is overridden for StateCompositeFlat etc which checks the sub states too.
    
    Parameters:
    
    recurs - recursion for sub states.
  - prepareTransitions
```
void prepareTransitions(StateSimple.Trans parent,
                        int nRecurs)
```
    Prepares all transitions. This method is public only for usage from StateMGen
  - prepareTransition
```
private void prepareTransition(StateSimple.Trans trans,
                               int nRecurs)
```
  - isInState
```
public final boolean isInState()
```
    Check and returns true if the enclosing state has this state as active one.
    
    Returns:
  - checkTrans
```
protected StateSimple.Trans checkTrans(java.util.EventObject ev)
```
    This method should be overridden by the user to select a transition which should be fire with given conditions.
    
    If only a breakpoint should be able to set the user should write: Q Override Trans selectTrans(Event ev) { return super.selectTrans(ev); }
    
    The returned transition will be fire in the calling environment. This method is invoked if StateMachine.processEvent(EventObject) is called.
    Template for the overridden method:
```
 Q Override Trans selectTrans(Event ev) {
   if(ev instanceof MyEvent) return trans_A;
   else if(otherCondition) return trans_B;
   else return null;
 }
```
    It is possible to write the action code immediately in this method. Then StateSimple.Trans.doExit() should be invoked before. If StateSimple.Trans.doExit() is not invoked the exit actions are executed after the transition code. That is not problematically but not conform to the UML state machine definition:
```
 Q Override Trans selectTrans(Event ev) {
   if(ev instanceof MyEvent){
     trans_A.doExit();  //it exits all necessary states may be from a deeper level.
     users_transition_code();  
     return trans_A;
   }
   else if(otherCondition) {
     users_transition_code();  
     //doExit() will be invoked from the calling level.
     return trans_B;
   }
   else return null;
 }
```
    The Transitions which are used here should be declared as fields of StateSimple.Trans which may be overridden anonymously. Especially the StateSimple.Trans.action(EventObject) can be overridden or the field StateSimple.Trans.action can be set. An overridden Trans#check(EventObject) field Trans#check of that transitions is not regarded.
    Template for the necessary transition definition:
```
 Trans trans_A = new Trans(Destination.class);   //without action
 
 Trans trans_B = new Trans(Destination.class) {
   protected void action(Event ev) {
     //do action code
   }
 };
 
 Trans trans_C = new Trans(Destination.class) {
   { action = ref.action;  //instanceof StateAction, callback 
   }
 };
```
    Parameters:
    
    ev - The event to test.
    
    Returns:
    
    The transition which should be fired or null.
  - processEvent
```
int processEvent(java.util.EventObject ev)
```
    Applies an event to this state respectively processes the event with this state. Note: This method is overridden by StateComposite.processEvent(EventObject) with an more complex algorithm. For a simple state it invokes only _checkTransitions(EventObject).
    
    Parameters:
    
    ev - The event to apply.
    
    Returns:
    
    information about the switch, Bits mEventConsumed, mTransit, mRunToComplete, mStateEntered, mStateLeaved.
  - _checkTransitions
```
final int _checkTransitions(java.util.EventObject ev)
```
    Check all transitions and fire one transition if true. This method is called primary in StateComposite#_processEvent(EventMsg2) if the state is active.
    
    Parameters:
    
    ev - Given event
    
    Returns:
    
    Bits mRunToComplete, 131072, mEventConsumed, mStateEntered to control the event processing.
  - printTransInfo
```
private void printTransInfo(StateSimple.Trans trans,
                            java.util.EventObject ev)
```
  - entryTheState
```
final int entryTheState(java.util.EventObject ev,
                        boolean history)
```
    Executes enter in this state. This routine will be invoked in StateSimple.Trans.doEntry(EventObject) immediately for the entry states, in StateCompositeFlat.entryDefaultState() or in StateComposite.entryDeepHistory(EventObject) or StateComposite.entryShallowHistory(EventObject). It enters only in this state. Enter is sub states is done in the calling routines.
    - The reference of StateComposite.stateAct will be set in its compositeState() to mark this state as current one..
    - The compositeState() (its composite) will be marked as StateComposite.isActive (may be marked already).
    - Sets debug informations: ctEntry+=1, dateLastEntry=yet, durationLast=0.
    - If it is a StateComposite without history, sets the own StateComposite.stateAct to null, therewith forces maybe entry in the default state if an entry in a member of the composite is not done by this transition but sets its own StateComposite.isActive. Note: The enter in the default state is done by the next state switch.
    - Note: If it has a history and it is an history entry, the StateComposite.stateAct will be entered as history state in the StateComposite.entryDeepHistory(EventObject) or StateComposite.entryShallowHistory(EventObject) in the StateSimple.Trans.doEntry(EventObject)
    - At least invokes the user defined entry(EventObject) action.
    Parameters:
    
    ev -
    
    Returns:
  - exitTheState
```
protected final void exitTheState(int level)
```
    Exits the state and all enclosing states till level.
    - If the state is a StateComposite, then this method is called recursively for the current state of composite. It means, the current state is exiting. If the current state of the StateComposite is a StateComposite too, this rule is valid for that too. It means, this method is called recursively for all StateComposite of the current statePath.
    - If the exit will be invoked for a StateCompositeFlat, this routine is called for the current StateSimple of the compositeState(). It means always the really current state will be exiting. See StateSimple.Trans.doExit().
    - If the state has a timeout evTimeout then it is removed from StateMachine.theThread. EventTimerThread.removeTimeEntry(TimeOrder).
    - If the state is a StateParallel all current parallel states are exiting.
    - The users exit() routine is invoked, or the exit is run, if setExitAction(Runnable) was set.
    - If StateMachine.debugEntryExit is set the exit text is written with System.out().
    - If the users routine is thrown an exception an System.err is written if StateMachine.permitException is set, or a RuntimeException is forwarding.
    Note: The routine is protected to see in documentation. It is final because all necessities for parallel and composite states are considered here already.
    Parameters:
    
    level - according to the statePath the last level which is exiting. It is the index in the statepath array.
  - getStatePath
```
java.lang.CharSequence getStatePath()
```
    Gets the path to this state. The path is build from the stateId of all enclosing states separated with a dot and at least this stateId. For example "topStateName.compositeState.thisState".
  - getName
```
public java.lang.String getName()
```
    Returns the name of the state, for debugging.
    
    Returns:
  - infoAppend
```
public java.lang.CharSequence infoAppend(java.lang.StringBuilder u)
```
    Description copied from interface: InfoAppend
    Appends or returns tan information about the instance. It is similar Object.toString() but it works with a given StringBuilder.
    Application pattern:
```
 StringBuilder u = new StringBulder(1000);
 u.append(something_else);
 
 myInstance.infoAppend(u);     //uses this interface
 
 u.append(some_more);
 System.out.append(u);             //output the information
 String savedInfo = u.toString();  //save permanent.
 
```
    Implementing pattern
```
 QOverride public infoAppend(StringBuilder u) {
   if(u == null){ u = new StringBuilder(); }  //it can be null!
   u.append(special_information).append(": ").append(somewhatElse);
   return u;
 }
 
```
    Contiguity with toString: It uses the same information, assembled in a StringBuilder:
```
 QOverride public String toString(){ return infoAppend(null).toString()); } 
 
```
    Specified by:
    
    infoAppend in interface InfoAppend
    
    Parameters:
    
    u - if not null then the info is appended to u, u is returned.
    if null then a String can be returned if it is sufficient.
    
    Returns:
    
    u if given or a new StringBuilder instance which contains the info or a String if it is sufficient.
  - toString
```
public java.lang.String toString()
```
    Returns the state Id and maybe some more debug information.
    
    Overrides:
    
    toString in class java.lang.Object
    
    See Also:
    
    Object.toString()

Class StateSimple

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

version

notTransit

mEventConsumed

mEventDonotRelinquish

mTransit

mStateEntered

mStateLeaved

mRunToComplete

mEventNotConsumed

stateMachine

enclState

compositeState

ixCompositeState_inStatePath

auxInfo

statePath

stateId

millisectimeout

transTimeout

evTimeout

modeTrans

ctEntry

dateLastEntry

durationLast

entry

exit

aTransitions

Constructor Detail

StateSimple

Method Detail

setAuxInfo

auxInfo

statePath

compositeState

enclState

setEntryAction

setExitAction

isTimeout

entry

exit

buildStatePathSubstates

buildStatePath

createTransitionListSubstate

createTransitionList

prepareTransitionsSubstate

prepareTransitions

prepareTransition

isInState

checkTrans

processEvent

_checkTransitions

printTransInfo

entryTheState

exitTheState

getStatePath

getName

infoAppend

toString