AbstractState (Spring State Machine 2.5.0 API)

java.lang.Object
- org.springframework.statemachine.support.LifecycleObjectSupport
- - org.springframework.statemachine.state.AbstractState<S,E>

Type Parameters:

S - the type of state

E - the type of event

All Implemented Interfaces:

org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanFactoryAware, org.springframework.beans.factory.DisposableBean, org.springframework.beans.factory.InitializingBean, org.springframework.context.Lifecycle, org.springframework.context.Phased, org.springframework.context.SmartLifecycle, State<S,E>

Direct Known Subclasses:

AbstractSimpleState, RegionState, StateMachineState
```
public abstract class AbstractState<S,E>
extends LifecycleObjectSupport
implements State<S,E>
```
Base implementation of a State.

Author:

Janne Valkealahti

Field Summary
- Fields inherited from interface org.springframework.context.SmartLifecycle
  DEFAULT_PHASE

Constructor Summary

Constructors
Constructor and Description
`AbstractState(S id, java.util.Collection<E> deferred)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions, java.util.Collection<? extends Action<S,E>> stateActions, PseudoState<S,E> pseudoState, java.util.Collection<Region<S,E>> regions, StateMachine<S,E> submachine)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions, PseudoState<S,E> pseudoState)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions, PseudoState<S,E> pseudoState, java.util.Collection<Region<S,E>> regions)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions, PseudoState<S,E> pseudoState, java.util.Collection<Region<S,E>> regions, StateMachine<S,E> submachine)` Instantiates a new abstract state.
`AbstractState(S id, java.util.Collection<E> deferred, java.util.Collection<? extends Action<S,E>> entryActions, java.util.Collection<? extends Action<S,E>> exitActions, PseudoState<S,E> pseudoState, StateMachine<S,E> submachine)` Instantiates a new abstract state.
`AbstractState(S id, PseudoState<S,E> pseudoState)` Instantiates a new abstract state.

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addActionListener(ActionListener<S,E> listener)` Adds the action listener.
`void`	`addStateListener(StateListener<S,E> listener)` Adds the state listener.
`protected void`	`armTriggers()` Arm triggers.
`protected void`	`cancelStateActions()` Cancel existing state actions and clear list.
`protected void`	`disarmTriggers()` Disarm triggers.
`protected void`	`doStart()` Subclasses may implement this method with the start behavior.
`protected void`	`doStop()` Subclasses may implement this method with the stop behavior.
`void`	`entry(StateContext<S,E> context)` Initiate an entry sequence for the state.
`protected void`	`executeAction(Action<S,E> action, StateContext<S,E> context)` Execute action and notify action listener if set.
`void`	`exit(StateContext<S,E> context)` Initiate an exit sequence for the state.
`java.util.Collection<E>`	`getDeferredEvents()` Gets the deferred events for this state.
`java.util.Collection<? extends Action<S,E>>`	`getEntryActions()` Gets `Action`s executed entering in this state.
`java.util.Collection<? extends Action<S,E>>`	`getExitActions()` Gets `Action`s executed exiting from this state.
`S`	`getId()` Gets the state identifier.
`abstract java.util.Collection<S>`	`getIds()` Gets the state identifiers.
`PseudoState<S,E>`	`getPseudoState()` Gets a `PseudoState` attached to a `State`.
`java.util.Collection<Region<S,E>>`	`getRegions()` Gets the regions.
`java.util.Collection<? extends Action<S,E>>`	`getStateActions()` Gets `Action`s executed once in this state.
`abstract java.util.Collection<State<S,E>>`	`getStates()` Gets all possible states this state knows about including itself and substates.
`StateMachine<S,E>`	`getSubmachine()` Gets the submachine.
`java.util.List<Trigger<S,E>>`	`getTriggers()` Gets the triggers.
`boolean`	`isComposite()` Checks if state is a composite state.
`boolean`	`isOrthogonal()` Checks if state is an orthogonal state.
`boolean`	`isSimple()` Checks if state is a simple state.
`boolean`	`isSubmachineState()` Checks if state is a submachine state.
`protected void`	`notifyStateOnComplete(StateContext<S,E> context)`
`void`	`removeActionListener(ActionListener<S,E> listener)` Removes the action listener.
`void`	`removeStateListener(StateListener<S,E> listener)` Removes the state listener.
`protected java.util.concurrent.ScheduledFuture<?>`	`scheduleAction(Action<S,E> action, StateContext<S,E> context, java.util.concurrent.atomic.AtomicInteger completionCount)` Schedule action and return future which can be used to cancel it.
`protected void`	`scheduleStateActions(StateContext<S,E> context)` Schedule state actions and store futures into list to be cancelled.
`boolean`	`sendEvent(org.springframework.messaging.Message<E> event)` Send an event `E` wrapped with a `Message` to the state.
`void`	`setStateDoActionPolicy(StateDoActionPolicy stateDoActionPolicy)`
`void`	`setStateDoActionPolicyTimeout(java.lang.Long stateDoActionPolicyTimeout)`
`void`	`setTriggers(java.util.List<Trigger<S,E>> triggers)` Sets the triggers.
`boolean`	`shouldDefer(org.springframework.messaging.Message<E> event)` Checks if state wants to defer an event.
`java.lang.String`	`toString()`

Methods inherited from class org.springframework.statemachine.support.LifecycleObjectSupport
afterPropertiesSet, destroy, doDestroy, getBeanFactory, getPhase, getTaskExecutor, getTaskScheduler, isAutoStartup, isRunning, onInit, setAutoStartup, setBeanFactory, setPhase, setTaskExecutor, setTaskScheduler, start, stop, stop

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

- Constructor Detail
  - AbstractState
```
public AbstractState(S id,
                     PseudoState<S,E> pseudoState)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    pseudoState - the pseudo state
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions,
                     PseudoState<S,E> pseudoState)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
    
    pseudoState - the pseudo state
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions,
                     PseudoState<S,E> pseudoState,
                     StateMachine<S,E> submachine)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
    
    pseudoState - the pseudo state
    
    submachine - the submachine
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions,
                     PseudoState<S,E> pseudoState,
                     java.util.Collection<Region<S,E>> regions)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
    
    pseudoState - the pseudo state
    
    regions - the regions
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions,
                     PseudoState<S,E> pseudoState,
                     java.util.Collection<Region<S,E>> regions,
                     StateMachine<S,E> submachine)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
    
    pseudoState - the pseudo state
    
    regions - the regions
    
    submachine - the submachine
  - AbstractState
```
public AbstractState(S id,
                     java.util.Collection<E> deferred,
                     java.util.Collection<? extends Action<S,E>> entryActions,
                     java.util.Collection<? extends Action<S,E>> exitActions,
                     java.util.Collection<? extends Action<S,E>> stateActions,
                     PseudoState<S,E> pseudoState,
                     java.util.Collection<Region<S,E>> regions,
                     StateMachine<S,E> submachine)
```
    Instantiates a new abstract state.
    
    Parameters:
    
    id - the state identifier
    
    deferred - the deferred
    
    entryActions - the entry actions
    
    exitActions - the exit actions
    
    stateActions - the state actions
    
    pseudoState - the pseudo state
    
    regions - the regions
    
    submachine - the submachine
- Method Detail
  - sendEvent
```
public boolean sendEvent(org.springframework.messaging.Message<E> event)
```
    Description copied from interface: State
    
    Send an event E wrapped with a Message to the state.
    
    Specified by:
    
    sendEvent in interface State<S,E>
    
    Parameters:
    
    event - the wrapped event to send
    
    Returns:
    
    true if event was accepted
  - shouldDefer
```
public boolean shouldDefer(org.springframework.messaging.Message<E> event)
```
    Description copied from interface: State
    
    Checks if state wants to defer an event.
    
    Specified by:
    
    shouldDefer in interface State<S,E>
    
    Parameters:
    
    event - the wrapped event
    
    Returns:
    
    true if event should be deferred
  - exit
```
public void exit(StateContext<S,E> context)
```
    Description copied from interface: State
    
    Initiate an exit sequence for the state.
    
    Specified by:
    
    exit in interface State<S,E>
    
    Parameters:
    
    context - the state context
  - entry
```
public void entry(StateContext<S,E> context)
```
    Description copied from interface: State
    
    Initiate an entry sequence for the state.
    
    Specified by:
    
    entry in interface State<S,E>
    
    Parameters:
    
    context - the state context
  - getId
```
public S getId()
```
    Description copied from interface: State
    
    Gets the state identifier.
    
    Specified by:
    
    getId in interface State<S,E>
    
    Returns:
    
    the state identifiers
  - getIds
```
public abstract java.util.Collection<S> getIds()
```
    Description copied from interface: State
    
    Gets the state identifiers. Usually returned collection contains only one identifier except in a case where state is an orthogonal.
    
    Specified by:
    
    getIds in interface State<S,E>
    
    Returns:
    
    the state identifiers
  - getStates
```
public abstract java.util.Collection<State<S,E>> getStates()
```
    Description copied from interface: State
    
    Gets all possible states this state knows about including itself and substates.
    
    Specified by:
    
    getStates in interface State<S,E>
    
    Returns:
    
    all state including itself and nested states
  - getPseudoState
```
public PseudoState<S,E> getPseudoState()
```
    Description copied from interface: State
    
    Gets a PseudoState attached to a State. PseudoState is not required and thus this method return NULL if it's not set.
    
    Specified by:
    
    getPseudoState in interface State<S,E>
    
    Returns:
    
    pseudostate or null if state doesn't have one
  - getDeferredEvents
```
public java.util.Collection<E> getDeferredEvents()
```
    Description copied from interface: State
    
    Gets the deferred events for this state.
    
    Specified by:
    
    getDeferredEvents in interface State<S,E>
    
    Returns:
    
    the state deferred events
  - getEntryActions
```
public java.util.Collection<? extends Action<S,E>> getEntryActions()
```
    Description copied from interface: State
    
    Gets Actions executed entering in this state.
    
    Specified by:
    
    getEntryActions in interface State<S,E>
    
    Returns:
    
    the state entry actions
  - getStateActions
```
public java.util.Collection<? extends Action<S,E>> getStateActions()
```
    Description copied from interface: State
    
    Gets Actions executed once in this state.
    
    Specified by:
    
    getStateActions in interface State<S,E>
    
    Returns:
    
    the state actions
  - getExitActions
```
public java.util.Collection<? extends Action<S,E>> getExitActions()
```
    Description copied from interface: State
    
    Gets Actions executed exiting from this state.
    
    Specified by:
    
    getExitActions in interface State<S,E>
    
    Returns:
    
    the state exit actions
  - isComposite
```
public boolean isComposite()
```
    Description copied from interface: State
    
    Checks if state is a composite state. A composite state is a state that contains at least one region.
    
    Specified by:
    
    isComposite in interface State<S,E>
    
    Returns:
    
    true, if state is a composite state
  - isOrthogonal
```
public boolean isOrthogonal()
```
    Description copied from interface: State
    
    Checks if state is an orthogonal state. An orthogonal composite state contains two or more regions. If this method returns TRUE, State.isComposite() will also always return TRUE.
    
    Specified by:
    
    isOrthogonal in interface State<S,E>
    
    Returns:
    
    true, if state is an orthogonal state
  - isSimple
```
public boolean isSimple()
```
    Description copied from interface: State
    
    Checks if state is a simple state. A simple state does not have any regions and it does not refer to any submachine state machine.
    
    Specified by:
    
    isSimple in interface State<S,E>
    
    Returns:
    
    true, if state is a simple state
  - isSubmachineState
```
public boolean isSubmachineState()
```
    Description copied from interface: State
    
    Checks if state is a submachine state. This kind of state refers to a state machine(submachine).
    
    Specified by:
    
    isSubmachineState in interface State<S,E>
    
    Returns:
    
    true, if state is a submachine state
  - addStateListener
```
public void addStateListener(StateListener<S,E> listener)
```
    Description copied from interface: State
    
    Adds the state listener.
    
    Specified by:
    
    addStateListener in interface State<S,E>
    
    Parameters:
    
    listener - the listener
  - removeStateListener
```
public void removeStateListener(StateListener<S,E> listener)
```
    Description copied from interface: State
    
    Removes the state listener.
    
    Specified by:
    
    removeStateListener in interface State<S,E>
    
    Parameters:
    
    listener - the listener
  - addActionListener
```
public void addActionListener(ActionListener<S,E> listener)
```
    Description copied from interface: State
    
    Adds the action listener.
    
    Specified by:
    
    addActionListener in interface State<S,E>
    
    Parameters:
    
    listener - the listener
  - removeActionListener
```
public void removeActionListener(ActionListener<S,E> listener)
```
    Description copied from interface: State
    
    Removes the action listener.
    
    Specified by:
    
    removeActionListener in interface State<S,E>
    
    Parameters:
    
    listener - the listener
  - doStart
```
protected void doStart()
```
    Description copied from class: LifecycleObjectSupport
    
    Subclasses may implement this method with the start behavior. This method will be invoked while holding the LifecycleObjectSupport.lifecycleLock.
    
    Overrides:
    
    doStart in class LifecycleObjectSupport
  - doStop
```
protected void doStop()
```
    Description copied from class: LifecycleObjectSupport
    
    Subclasses may implement this method with the stop behavior. This method will be invoked while holding the LifecycleObjectSupport.lifecycleLock.
    
    Overrides:
    
    doStop in class LifecycleObjectSupport
  - getSubmachine
```
public StateMachine<S,E> getSubmachine()
```
    Gets the submachine.
    
    Returns:
    
    the submachine or null if not set
  - getRegions
```
public java.util.Collection<Region<S,E>> getRegions()
```
    Gets the regions.
    
    Returns:
    
    the regions or empty collection if no regions
  - setTriggers
```
public void setTriggers(java.util.List<Trigger<S,E>> triggers)
```
    Sets the triggers.
    
    Parameters:
    
    triggers - the triggers
  - getTriggers
```
public java.util.List<Trigger<S,E>> getTriggers()
```
    Gets the triggers.
    
    Returns:
    
    the triggers
  - setStateDoActionPolicy
```
public void setStateDoActionPolicy(StateDoActionPolicy stateDoActionPolicy)
```
  - setStateDoActionPolicyTimeout
```
public void setStateDoActionPolicyTimeout(java.lang.Long stateDoActionPolicyTimeout)
```
  - armTriggers
```
protected void armTriggers()
```
    Arm triggers.
  - disarmTriggers
```
protected void disarmTriggers()
```
    Disarm triggers.
  - cancelStateActions
```
protected void cancelStateActions()
```
    Cancel existing state actions and clear list.
  - scheduleStateActions
```
protected void scheduleStateActions(StateContext<S,E> context)
```
    Schedule state actions and store futures into list to be cancelled.
    
    Parameters:
    
    context - the context
  - executeAction
```
protected void executeAction(Action<S,E> action,
                             StateContext<S,E> context)
```
    Execute action and notify action listener if set.
    
    Parameters:
    
    action - the action
    
    context - the context
  - scheduleAction
```
protected java.util.concurrent.ScheduledFuture<?> scheduleAction(Action<S,E> action,
                                                                 StateContext<S,E> context,
                                                                 java.util.concurrent.atomic.AtomicInteger completionCount)
```
    Schedule action and return future which can be used to cancel it.
    
    Parameters:
    
    action - the action
    
    context - the context
    
    completionCount - the completion count tracker
    
    Returns:
    
    the scheduled future
  - notifyStateOnComplete
```
protected void notifyStateOnComplete(StateContext<S,E> context)
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object

Class AbstractState<S,E>

Field Summary

Fields inherited from interface org.springframework.context.SmartLifecycle

Constructor Summary

Method Summary

Methods inherited from class org.springframework.statemachine.support.LifecycleObjectSupport

Methods inherited from class java.lang.Object

Constructor Detail

AbstractState

AbstractState

AbstractState

AbstractState

AbstractState

AbstractState

AbstractState

AbstractState

Method Detail

sendEvent

shouldDefer

exit

entry

getId

getIds

getStates

getPseudoState

getDeferredEvents

getEntryActions

getStateActions

getExitActions

isComposite

isOrthogonal

isSimple

isSubmachineState

addStateListener

removeStateListener

addActionListener

removeActionListener

doStart

doStop

getSubmachine

getRegions

setTriggers

getTriggers

setStateDoActionPolicy

setStateDoActionPolicyTimeout

armTriggers

disarmTriggers

cancelStateActions

scheduleStateActions

executeAction

scheduleAction

notifyStateOnComplete

toString