org.vishia.states

Class StateCompositeFlat

java.lang.Object

org.vishia.states.StateSimple

org.vishia.states.StateCompositeFlat

All Implemented Interfaces:

InfoAppend

Direct Known Subclasses:

StateComposite

public abstract class StateCompositeFlat
extends StateSimple
implements InfoAppend

Super class for a composite state which does not contain a history and which is not parallel to other StateComposite. Therefore it can use the state variable of its enclosing StateComposite. A composite state has two core properties:

• can have a history, if necessary
• transitions from the composite are the same as one transition per inner state, but in lower priority.

The last one property is provided from this StateCompositeFlat by the StateComposite.processEvent(java.util.EventObject) which checks whether the state StateComposite.stateAct refers a StateSimple.enclState as StateCompositeFlat. Then its transitions are checked after checking the transitions of the actual state.

This class is the super class of StateComposite because it provides half of its properties. The top state or a composite state inside a StateParallel should be of type StateComposite because it needs a StateComposite.stateAct to control the state processing.

Nested Class Summary

Nested classes/interfaces inherited from class org.vishia.states.StateSimple

StateSimple.PlugStateSimpleToGenState, StateSimple.Timeout, StateSimple.Trans, StateSimple.TransChoice, StateSimple.TransJoin

Field Summary

Fields

Modifier and Type	Field and Description
(package private) StateSimple[]	aSubstates List of all sub states of this composite state.
(package private) StateSimple	stateDefault
static int	version Version, history and license.

Fields inherited from class org.vishia.states.StateSimple

compositeState, ctEntry, dateLastEntry, durationLast, enclState, entry, evTimeout, exit, ixCompositeState_inStatePath, mEventConsumed, mEventDonotRelinquish, mEventNotConsumed, millisectimeout, modeTrans, mRunToComplete, mStateEntered, mStateLeaved, mTransit, notTransit, stateId, stateMachine, statePath, transTimeout

Constructor Summary

Constructors

Constructor and Description
StateCompositeFlat() The constructor of any StateComposite checks the class for inner classes which are the states.
StateCompositeFlat(java.lang.String name, StateMachine stateMachine, StateSimple[] aSubstates) Only used for the StateMachine.stateTop and as special constructor to build a state machine from other data.

Method Summary

Modifier and Type	Method and Description
void	addState(int key, StateSimple state) It is called from outside if the state machine is build other than with Reflection.
(package private) void	buildStatePathSubstates(StateSimple enclState, int recurs) Sets the path to the state for this and all aSubstates, recursively call.
(package private) void	createTransitionListSubstate(int recurs) Create all transition list for this state and all aSubstates, recursively call.
(package private) int	entryDefaultState() This method is used to entry the default state of this composite if the actual state is null (first invocation).
(package private) void	prepareTransitionsSubstate(int recurs) Prepare all transitions for this state and all aSubstates, recursively call.
StateSimple	stateDefault()

Methods inherited from class org.vishia.states.StateSimple

_checkTransitions, auxInfo, buildStatePath, checkTrans, compositeState, createTransitionList, enclState, entry, entryTheState, exit, exitTheState, getName, getStatePath, infoAppend, isInState, isTimeout, prepareTransitions, processEvent, setAuxInfo, setEntryAction, setExitAction, statePath, toString

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.vishia.util.InfoAppend

infoAppend

Field Detail

version

public static final int version

Version, history and license.

• 2015-02-09 Hartmut created, copied parts from StateComposite. Reason: Too many recursions while using StateComposite, not well for debugging. States in C should not use one state variable per composite if it is not necessary. A own state variable per composite state is only necessary if the composite should store a history state.

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 is 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

stateDefault

StateSimple stateDefault

aSubstates

final StateSimple[] aSubstates

List of all sub states of this composite state. This list is necessary to build the transition paths on startup. It is nice to have for debugging. Therefore its name starts with 'a' to set it on top of variable list in debugging.

Constructor Detail

StateCompositeFlat

public StateCompositeFlat(java.lang.String name,
                          StateMachine stateMachine,
                          StateSimple[] aSubstates)

Only used for the StateMachine.stateTop and as special constructor to build a state machine from other data. See org.vishia.stateMGen.StateMGen.

StateCompositeFlat

public StateCompositeFlat()

The constructor of any StateComposite checks the class for inner classes which are the states. Each inner class which is instance of StateSimple is instantiated and stored both in the StateMachine.stateMap to find all states by its class.hashCode and in aSubstates for debugging only.

After them #buildStatePathSubstates() is invoked to store the state path in all states. Then createTransitionListSubstate(int) is invoked which checks the transition of all states recursively. Therewith all necessary data for the state machines's processing are created on construction.

See Also:

StateMachine#StateMachine(), StateComposite#buildStatePathSubstates(StateComposite, int), StateSimple#buildStatePath(StateComposite), createTransitionListSubstate(int), StateSimple#createTransitionList()

Method Detail

addState

public void addState(int key,
                     StateSimple state)

It is called from outside if the state machine is build other than with Reflection.

Parameters:

key - the key which is used to find the state in StateMachine.stateMap while preparing the transitions

state - a new inner state.

stateDefault

public StateSimple stateDefault()

buildStatePathSubstates

void buildStatePathSubstates(StateSimple enclState,
                             int recurs)

Sets the path to the state for this and all aSubstates, recursively call. This method is invoked in the constructor of the state machine only one time. It is not for application.

Overrides:

buildStatePathSubstates in class StateSimple

Parameters:

enclState -

recurs -

createTransitionListSubstate

void createTransitionListSubstate(int recurs)

Create all transition list for this state and all aSubstates, recursively call. This method is invoked in the constructor of the state machine only one time. It is not for application.

Overrides:

createTransitionListSubstate in class StateSimple

Parameters:

recurs -

prepareTransitionsSubstate

void prepareTransitionsSubstate(int recurs)

Prepare all transitions for this state and all aSubstates, recursively call. This method is invoked in the constructor of the state machine only one time. It is not for application.

Overrides:

prepareTransitionsSubstate in class StateSimple

Parameters:

recurs -

entryDefaultState

final int entryDefaultState()

This method is used to entry the default state of this composite if the actual state is null (first invocation).