java.lang.Object
- akka.actor.AbstractFSM<S,D>

All Implemented Interfaces:

Actor, ActorLogging, FSM<S,D>, Listeners

Direct Known Subclasses:

AbstractFSMWithStash, AbstractLoggingFSM
```
public abstract class AbstractFSM<S,D>
extends java.lang.Object
implements FSM<S,D>
```
Java API: compatible with lambda expressions
Finite State Machine actor abstract base class.

Nested Class Summary
- Nested classes/interfaces inherited from interface akka.actor.Actor
  Actor.emptyBehavior$, Actor.ignoringBehavior$
- Nested classes/interfaces inherited from interface akka.actor.FSM
  FSM.$minus$greater$, FSM.CurrentState<S>, FSM.CurrentState$, FSM.Event<D>, FSM.Event$, FSM.Failure, FSM.Failure$, FSM.FixedDelayMode$, FSM.FixedRateMode$, FSM.LogEntry<S,D>, FSM.LogEntry$, FSM.Normal$, FSM.NullFunction$, FSM.Reason, FSM.Shutdown$, FSM.SilentState<S,D>, FSM.SingleMode$, FSM.State<S,D>, FSM.State$, FSM.StateTimeout$, FSM.StopEvent<S,D>, FSM.StopEvent$, FSM.SubscribeTransitionCallBack, FSM.SubscribeTransitionCallBack$, FSM.Timer, FSM.Timer$, FSM.TimerMode, FSM.TransformHelper, FSM.Transition<S>, FSM.Transition$, FSM.UnsubscribeTransitionCallBack, FSM.UnsubscribeTransitionCallBack$

Constructor Summary

Constructors
Constructor Description

AbstractFSM()

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`FSM.$minus$greater$`	`$minus$greater()`	This extractor is just convenience for matching a (S, S) pair, including a reminder what the new state is.
`protected void`	`akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)`	Scala API: Stores the context for this actor, including self, and sender.
`protected void`	`akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)`	The 'self' field holds the ActorRef for this actor.
`protected void`	`akka$actor$FSM$_setter_$Event_$eq(FSM.Event$ x$1)`
`protected void`	`akka$actor$FSM$_setter_$StateTimeout_$eq(FSM.StateTimeout$ x$1)`	This case object is received in case of a state timeout.
`protected void`	`akka$actor$FSM$_setter_$StopEvent_$eq(FSM.StopEvent$ x$1)`
`protected void`	`akka$routing$Listeners$_setter_$listeners_$eq(java.util.Set<ActorRef> x$1)`
`ActorContext`	`context()`	Scala API: Stores the context for this actor, including self, and sender.
`FSM.Event$`	`Event()`
`AbstractActor.ActorContext`	`getContext()`	Returns this AbstractActor's ActorContext The ActorContext is not thread safe so do not expose it outside of the AbstractActor.
`ActorRef`	`getSelf()`	Returns the ActorRef for this actor.
`ActorRef`	`getSender()`	The reference sender Actor of the currently processed message.
`FSM.State<S,D>`	`goTo(S nextStateName)`	Produce transition to other state.
`protected java.util.Set<ActorRef>`	`listeners()`
`FSMStateFunctionBuilder<S,D>`	`matchAnyEvent(FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<DT extends D> UnitPFBuilder<D>`	`matchData(java.lang.Class<DT> dataType, FI.TypedPredicate<DT> predicate, FI.UnitApply<DT> apply)`	Create a `UnitPFBuilder` with the first case statement set.
`<DT extends D> UnitPFBuilder<D>`	`matchData(java.lang.Class<DT> dataType, FI.UnitApply<DT> apply)`	Create a `UnitPFBuilder` with the first case statement set.
`FSMStateFunctionBuilder<S,D>`	`matchEvent(FI.TypedPredicate2<java.lang.Object,D> predicate, FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<ET> FSMStateFunctionBuilder<S,D>`	`matchEvent(java.lang.Class<ET> eventType, FI.Apply2<ET,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<ET> FSMStateFunctionBuilder<S,D>`	`matchEvent(java.lang.Class<ET> eventType, FI.TypedPredicate2<ET,D> predicate, FI.Apply2<ET,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<ET,DT extends D> FSMStateFunctionBuilder<S,D>`	`matchEvent(java.lang.Class<ET> eventType, java.lang.Class<DT> dataType, FI.Apply2<ET,DT,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<ET,DT extends D> FSMStateFunctionBuilder<S,D>`	`matchEvent(java.lang.Class<ET> eventType, java.lang.Class<DT> dataType, FI.TypedPredicate2<ET,DT> predicate, FI.Apply2<ET,DT,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`FSMStateFunctionBuilder<S,D>`	`matchEvent(java.util.List<java.lang.Object> eventMatches, FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<DT extends D> FSMStateFunctionBuilder<S,D>`	`matchEvent(java.util.List<java.lang.Object> eventMatches, java.lang.Class<DT> dataType, FI.Apply2<java.lang.Object,DT,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<E> FSMStateFunctionBuilder<S,D>`	`matchEventEquals(E event, FI.Apply2<E,D,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`<E,DT extends D> FSMStateFunctionBuilder<S,D>`	`matchEventEquals(E event, java.lang.Class<DT> dataType, FI.Apply2<E,DT,FSM.State<S,D>> apply)`	Create an `FSMStateFunctionBuilder` with the first case statement set.
`FSMTransitionHandlerBuilder<S>`	`matchState(S fromState, S toState, FI.UnitApply2<S,S> apply)`	Create an `FSMTransitionHandlerBuilder` with the first case statement set.
`FSMTransitionHandlerBuilder<S>`	`matchState(S fromState, S toState, FI.UnitApplyVoid apply)`	Create an `FSMTransitionHandlerBuilder` with the first case statement set.
`FSMStopBuilder<S,D>`	`matchStop(FSM.Reason reason, FI.UnitApply2<S,D> apply)`	Create an `FSMStopBuilder` with the first case statement set.
`<RT extends FSM.Reason> FSMStopBuilder<S,D>`	`matchStop(java.lang.Class<RT> reasonType, FI.TypedPredicate<RT> predicate, FI.UnitApply3<RT,S,D> apply)`	Create an `FSMStopBuilder` with the first case statement set.
`<RT extends FSM.Reason> FSMStopBuilder<S,D>`	`matchStop(java.lang.Class<RT> reasonType, FI.UnitApply3<RT,S,D> apply)`	Create an `FSMStopBuilder` with the first case statement set.
`FSM.Reason`	`Normal()`	Default reason if calling `stop()`.
`static <S,D> scala.PartialFunction<S,D>`	`NullFunction()`	A partial function value which does not match anything and can be used to “reset” `whenUnhandled` and `onTermination` handlers.
`void`	`onTermination(FSMStopBuilder<S,D> stopBuilder)`	Set handler which is called upon termination of this FSM actor.
`void`	`onTransition(FI.UnitApply2<S,S> transitionHandler)`	Add a handler which is called upon each state transition, i.e.
`void`	`onTransition(FSMTransitionHandlerBuilder<S> transitionHandlerBuilder)`	Add a handler which is called upon each state transition, i.e.
`ActorRef`	`self()`	The 'self' field holds the ActorRef for this actor.
`void`	`setTimer(java.lang.String name, java.lang.Object msg, java.time.Duration timeout)`	Deprecated. Use startSingleTimer instead.
`void`	`setTimer(java.lang.String name, java.lang.Object msg, java.time.Duration timeout, boolean repeat)`	Deprecated. Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead.
`void`	`setTimer(java.lang.String name, java.lang.Object msg, scala.concurrent.duration.FiniteDuration timeout)`	Deprecated. Use startSingleTimer instead.
`FSM.Reason`	`Shutdown()`	Reason given when someone was calling `system.stop(fsm)` from outside; also applies to `Stop` supervision directive.
`void`	`startSingleTimer(java.lang.String name, java.lang.Object msg, java.time.Duration delay)`	Start a timer that will send `msg` once to the `self` actor after the given `delay`.
`void`	`startTimerAtFixedRate(java.lang.String name, java.lang.Object msg, java.time.Duration interval)`	Schedules a message to be sent repeatedly to the `self` actor with a given frequency.
`void`	`startTimerWithFixedDelay(java.lang.String name, java.lang.Object msg, java.time.Duration delay)`	Schedules a message to be sent repeatedly to the `self` actor with a fixed `delay` between messages.
`void`	`startWith(S stateName, D stateData)`	Set initial state.
`void`	`startWith(S stateName, D stateData, java.time.Duration timeout)`	Set initial state.
`void`	`startWith(S stateName, D stateData, scala.concurrent.duration.FiniteDuration timeout)`	Set initial state.
`FSM.StateTimeout$`	`StateTimeout()`	This case object is received in case of a state timeout.
`FSM.StopEvent$`	`StopEvent()`
`void`	`when(S stateName, FSMStateFunctionBuilder<S,D> stateFunctionBuilder)`	Insert a new StateFunction at the end of the processing chain for the given state.
`void`	`when(S stateName, java.time.Duration stateTimeout, FSMStateFunctionBuilder<S,D> stateFunctionBuilder)`	Insert a new StateFunction at the end of the processing chain for the given state.
`void`	`when(S stateName, scala.concurrent.duration.FiniteDuration stateTimeout, FSMStateFunctionBuilder<S,D> stateFunctionBuilder)`	Insert a new StateFunction at the end of the processing chain for the given state.
`void`	`when(S stateName, scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)`	Insert a new StateFunction at the end of the processing chain for the given state.
`void`	`whenUnhandled(FSMStateFunctionBuilder<S,D> stateFunctionBuilder)`	Set handler which is called upon reception of unhandled messages.

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

Methods inherited from interface akka.actor.Actor
aroundPostRestart, aroundPostStop, aroundPreRestart, aroundPreStart, aroundReceive, postRestart, preRestart, preStart, sender, supervisorStrategy, unhandled

Methods inherited from interface akka.actor.ActorLogging
_log_$eq, log

Methods inherited from interface akka.routing.Listeners
gossip, gossip$default$2, listenerManagement

- Constructor Detail
  - AbstractFSM
```
public AbstractFSM()
```
- Method Detail
  - NullFunction
```
public static <S,D> scala.PartialFunction<S,D> NullFunction()
```
    A partial function value which does not match anything and can be used to “reset” whenUnhandled and onTermination handlers.
    
    onTermination(FSM.NullFunction())
  - Event
```
public FSM.Event$ Event()
```
    Specified by:
    
    Event in interface FSM<S,D>
  - StopEvent
```
public FSM.StopEvent$ StopEvent()
```
    Specified by:
    
    StopEvent in interface FSM<S,D>
  - $minus$greater
```
public FSM.$minus$greater$ $minus$greater()
```
    Description copied from interface: FSM
    
    This extractor is just convenience for matching a (S, S) pair, including a reminder what the new state is.
    
    Specified by:
    
    $minus$greater in interface FSM<S,D>
  - StateTimeout
```
public FSM.StateTimeout$ StateTimeout()
```
    Description copied from interface: FSM
    
    This case object is received in case of a state timeout.
    
    Specified by:
    
    StateTimeout in interface FSM<S,D>
  - akka$actor$FSM$_setter_$Event_$eq
```
protected void akka$actor$FSM$_setter_$Event_$eq(FSM.Event$ x$1)
```
    Specified by:
    
    akka$actor$FSM$_setter_$Event_$eq in interface FSM<S,D>
  - akka$actor$FSM$_setter_$StopEvent_$eq
```
protected void akka$actor$FSM$_setter_$StopEvent_$eq(FSM.StopEvent$ x$1)
```
    Specified by:
    
    akka$actor$FSM$_setter_$StopEvent_$eq in interface FSM<S,D>
  - akka$actor$FSM$_setter_$StateTimeout_$eq
```
protected void akka$actor$FSM$_setter_$StateTimeout_$eq(FSM.StateTimeout$ x$1)
```
    Description copied from interface: FSM
    
    This case object is received in case of a state timeout.
    
    Specified by:
    
    akka$actor$FSM$_setter_$StateTimeout_$eq in interface FSM<S,D>
  - listeners
```
protected java.util.Set<ActorRef> listeners()
```
    Specified by:
    
    listeners in interface Listeners
  - akka$routing$Listeners$_setter_$listeners_$eq
```
protected void akka$routing$Listeners$_setter_$listeners_$eq(java.util.Set<ActorRef> x$1)
```
    Specified by:
    
    akka$routing$Listeners$_setter_$listeners_$eq in interface Listeners
  - context
```
public ActorContext context()
```
    Description copied from interface: Actor
    
    Scala API: Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.
    WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
    ActorContext is the Scala API. getContext returns a AbstractActor.ActorContext, which is the Java API of the actor context.
    
    Specified by:
    
    context in interface Actor
  - self
```
public final ActorRef self()
```
    Description copied from interface: Actor
    The 'self' field holds the ActorRef for this actor.
    Can be used to send messages to itself:
    self ! message
    Specified by:
    
    self in interface Actor
  - akka$actor$Actor$_setter_$context_$eq
```
protected void akka$actor$Actor$_setter_$context_$eq(ActorContext x$1)
```
    Description copied from interface: Actor
    
    Scala API: Stores the context for this actor, including self, and sender. It is implicit to support operations such as forward.
    WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
    ActorContext is the Scala API. getContext returns a AbstractActor.ActorContext, which is the Java API of the actor context.
    
    Specified by:
    
    akka$actor$Actor$_setter_$context_$eq in interface Actor
  - akka$actor$Actor$_setter_$self_$eq
```
protected final void akka$actor$Actor$_setter_$self_$eq(ActorRef x$1)
```
    Description copied from interface: Actor
    The 'self' field holds the ActorRef for this actor.
    Can be used to send messages to itself:
    self ! message
    Specified by:
    
    akka$actor$Actor$_setter_$self_$eq in interface Actor
  - getContext
```
public AbstractActor.ActorContext getContext()
```
    Returns this AbstractActor's ActorContext The ActorContext is not thread safe so do not expose it outside of the AbstractActor.
  - getSelf
```
public ActorRef getSelf()
```
    Returns the ActorRef for this actor.
    Same as self().
  - getSender
```
public ActorRef getSender()
```
    The reference sender Actor of the currently processed message. This is always a legal destination to send to, even if there is no logical recipient for the reply, in which case it will be sent to the dead letter mailbox.
    Same as sender().
    WARNING: Only valid within the Actor itself, so do not close over it and publish it to other threads!
  - when
```
public final void when(S stateName,
                       scala.PartialFunction<FSM.Event<D>,FSM.State<S,D>> stateFunction)
```
    Insert a new StateFunction at the end of the processing chain for the given state.
    
    Parameters:
    
    stateName - designator for the state
    
    stateFunction - partial function describing response to input
  - when
```
public final void when(S stateName,
                       FSMStateFunctionBuilder<S,D> stateFunctionBuilder)
```
    Insert a new StateFunction at the end of the processing chain for the given state.
    
    Parameters:
    
    stateName - designator for the state
    
    stateFunctionBuilder - partial function builder describing response to input
  - when
```
public final void when(S stateName,
                       scala.concurrent.duration.FiniteDuration stateTimeout,
                       FSMStateFunctionBuilder<S,D> stateFunctionBuilder)
```
    Insert a new StateFunction at the end of the processing chain for the given state. If the stateTimeout parameter is set, entering this state without a differing explicit timeout setting will trigger a StateTimeout event; the same is true when using #stay.
    
    Parameters:
    
    stateName - designator for the state
    
    stateTimeout - default state timeout for this state
    
    stateFunctionBuilder - partial function builder describing response to input
  - when
```
public final void when(S stateName,
                       java.time.Duration stateTimeout,
                       FSMStateFunctionBuilder<S,D> stateFunctionBuilder)
```
    Insert a new StateFunction at the end of the processing chain for the given state. If the stateTimeout parameter is set, entering this state without a differing explicit timeout setting will trigger a StateTimeout event; the same is true when using #stay.
    
    Parameters:
    
    stateName - designator for the state
    
    stateTimeout - default state timeout for this state
    
    stateFunctionBuilder - partial function builder describing response to input
  - startWith
```
public final void startWith(S stateName,
                            D stateData)
```
    Set initial state. Call this method from the constructor before the FSM.initialize() method. If different state is needed after a restart this method, followed by FSM.initialize(), can be used in the actor life cycle hooks Actor.preStart() and Actor.postRestart(java.lang.Throwable).
    
    Parameters:
    
    stateName - initial state designator
    
    stateData - initial state data
  - startWith
```
public final void startWith(S stateName,
                            D stateData,
                            scala.concurrent.duration.FiniteDuration timeout)
```
    Set initial state. Call this method from the constructor before the FSM.initialize() method. If different state is needed after a restart this method, followed by FSM.initialize(), can be used in the actor life cycle hooks Actor.preStart() and Actor.postRestart(java.lang.Throwable).
    
    Parameters:
    
    stateName - initial state designator
    
    stateData - initial state data
    
    timeout - state timeout for the initial state, overriding the default timeout for that state
  - startWith
```
public final void startWith(S stateName,
                            D stateData,
                            java.time.Duration timeout)
```
    Set initial state. Call this method from the constructor before the FSM.initialize() method. If different state is needed after a restart this method, followed by FSM.initialize(), can be used in the actor life cycle hooks Actor.preStart() and Actor.postRestart(java.lang.Throwable).
    
    Parameters:
    
    stateName - initial state designator
    
    stateData - initial state data
    
    timeout - state timeout for the initial state, overriding the default timeout for that state
  - onTransition
```
public final void onTransition(FSMTransitionHandlerBuilder<S> transitionHandlerBuilder)
```
    Add a handler which is called upon each state transition, i.e. not when staying in the same state.
    Multiple handlers may be installed, and every one of them will be called, not only the first one matching.
  - onTransition
```
public final void onTransition(FI.UnitApply2<S,S> transitionHandler)
```
    Add a handler which is called upon each state transition, i.e. not when staying in the same state.
    Multiple handlers may be installed, and every one of them will be called, not only the first one matching.
  - whenUnhandled
```
public final void whenUnhandled(FSMStateFunctionBuilder<S,D> stateFunctionBuilder)
```
    Set handler which is called upon reception of unhandled messages. Calling this method again will overwrite the previous contents.
    The current state may be queried using stateName.
  - onTermination
```
public final void onTermination(FSMStopBuilder<S,D> stopBuilder)
```
    Set handler which is called upon termination of this FSM actor. Calling this method again will overwrite the previous contents.
  - matchEvent
```
public final <ET,DT extends D> FSMStateFunctionBuilder<S,D> matchEvent(java.lang.Class<ET> eventType,
                                                                                   java.lang.Class<DT> dataType,
                                                                                   FI.TypedPredicate2<ET,DT> predicate,
                                                                                   FI.Apply2<ET,DT,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches on an event and data type and a predicate.
    
    Parameters:
    
    eventType - the event type to match on
    
    dataType - the data type to match on
    
    predicate - a predicate to evaluate on the matched types
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final <ET,DT extends D> FSMStateFunctionBuilder<S,D> matchEvent(java.lang.Class<ET> eventType,
                                                                                   java.lang.Class<DT> dataType,
                                                                                   FI.Apply2<ET,DT,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches on an event and data type.
    
    Parameters:
    
    eventType - the event type to match on
    
    dataType - the data type to match on
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final <ET> FSMStateFunctionBuilder<S,D> matchEvent(java.lang.Class<ET> eventType,
                                                                FI.TypedPredicate2<ET,D> predicate,
                                                                FI.Apply2<ET,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches if the event type and predicate matches.
    
    Parameters:
    
    eventType - the event type to match on
    
    predicate - a predicate that will be evaluated on the data and the event
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final <ET> FSMStateFunctionBuilder<S,D> matchEvent(java.lang.Class<ET> eventType,
                                                                FI.Apply2<ET,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches if the event type matches.
    
    Parameters:
    
    eventType - the event type to match on
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final FSMStateFunctionBuilder<S,D> matchEvent(FI.TypedPredicate2<java.lang.Object,D> predicate,
                                                           FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches if the predicate matches.
    
    Parameters:
    
    predicate - a predicate that will be evaluated on the data and the event
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final <DT extends D> FSMStateFunctionBuilder<S,D> matchEvent(java.util.List<java.lang.Object> eventMatches,
                                                                          java.lang.Class<DT> dataType,
                                                                          FI.Apply2<java.lang.Object,DT,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches on the data type and if any of the event types in the list match or any of the event instances in the list compares equal.
    
    Parameters:
    
    eventMatches - a list of types or instances to match against
    
    dataType - the data type to match on
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEvent
```
public final FSMStateFunctionBuilder<S,D> matchEvent(java.util.List<java.lang.Object> eventMatches,
                                                           FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches if any of the event types in the list match or any of the event instances in the list compares equal.
    
    Parameters:
    
    eventMatches - a list of types or instances to match against
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEventEquals
```
public final <E,DT extends D> FSMStateFunctionBuilder<S,D> matchEventEquals(E event,
                                                                                        java.lang.Class<DT> dataType,
                                                                                        FI.Apply2<E,DT,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches on the data type and if the event compares equal.
    
    Parameters:
    
    event - an event to compare equal against
    
    dataType - the data type to match on
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchEventEquals
```
public final <E> FSMStateFunctionBuilder<S,D> matchEventEquals(E event,
                                                                     FI.Apply2<E,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches if the event compares equal.
    
    Parameters:
    
    event - an event to compare equal against
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchAnyEvent
```
public final FSMStateFunctionBuilder<S,D> matchAnyEvent(FI.Apply2<java.lang.Object,D,FSM.State<S,D>> apply)
```
    Create an FSMStateFunctionBuilder with the first case statement set.
    A case statement that matches on any type of event.
    
    Parameters:
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchState
```
public final FSMTransitionHandlerBuilder<S> matchState(S fromState,
                                                       S toState,
                                                       FI.UnitApplyVoid apply)
```
    Create an FSMTransitionHandlerBuilder with the first case statement set.
    A case statement that matches on a from state and a to state.
    
    Parameters:
    
    fromState - the from state to match on
    
    toState - the to state to match on
    
    apply - an action to apply when the states match
    
    Returns:
    
    the builder with the case statement added
  - matchState
```
public final FSMTransitionHandlerBuilder<S> matchState(S fromState,
                                                       S toState,
                                                       FI.UnitApply2<S,S> apply)
```
    Create an FSMTransitionHandlerBuilder with the first case statement set.
    A case statement that matches on a from state and a to state.
    
    Parameters:
    
    fromState - the from state to match on
    
    toState - the to state to match on
    
    apply - an action to apply when the states match
    
    Returns:
    
    the builder with the case statement added
  - matchStop
```
public final FSMStopBuilder<S,D> matchStop(FSM.Reason reason,
                                                 FI.UnitApply2<S,D> apply)
```
    Create an FSMStopBuilder with the first case statement set.
    A case statement that matches on an FSM.Reason.
    
    Parameters:
    
    reason - the reason for the termination
    
    apply - an action to apply to the event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchStop
```
public final <RT extends FSM.Reason> FSMStopBuilder<S,D> matchStop(java.lang.Class<RT> reasonType,
                                                                         FI.UnitApply3<RT,S,D> apply)
```
    Create an FSMStopBuilder with the first case statement set.
    A case statement that matches on a reason type.
    
    Parameters:
    
    reasonType - the reason type to match on
    
    apply - an action to apply to the reason, event and state data if there is a match
    
    Returns:
    
    the builder with the case statement added
  - matchStop
```
public final <RT extends FSM.Reason> FSMStopBuilder<S,D> matchStop(java.lang.Class<RT> reasonType,
                                                                         FI.TypedPredicate<RT> predicate,
                                                                         FI.UnitApply3<RT,S,D> apply)
```
    Create an FSMStopBuilder with the first case statement set.
    A case statement that matches on a reason type and a predicate.
    
    Parameters:
    
    reasonType - the reason type to match on
    
    apply - an action to apply to the reason, event and state data if there is a match
    
    predicate - a predicate that will be evaluated on the reason if the type matches
    
    Returns:
    
    the builder with the case statement added
  - matchData
```
public final <DT extends D> UnitPFBuilder<D> matchData(java.lang.Class<DT> dataType,
                                                       FI.UnitApply<DT> apply)
```
    Create a UnitPFBuilder with the first case statement set.
    
    Parameters:
    
    dataType - a type to match the argument against
    
    apply - an action to apply to the argument if the type matches
    
    Returns:
    
    a builder with the case statement added
  - matchData
```
public final <DT extends D> UnitPFBuilder<D> matchData(java.lang.Class<DT> dataType,
                                                       FI.TypedPredicate<DT> predicate,
                                                       FI.UnitApply<DT> apply)
```
    Create a UnitPFBuilder with the first case statement set.
    
    Parameters:
    
    dataType - a type to match the argument against
    
    predicate - a predicate that will be evaluated on the argument if the type matches
    
    apply - an action to apply to the argument if the type and predicate matches
    
    Returns:
    
    a builder with the case statement added
  - goTo
```
public final FSM.State<S,D> goTo(S nextStateName)
```
    Produce transition to other state. Return this from a state function in order to effect the transition.
    
    Parameters:
    
    nextStateName - state designator for the next state
    
    Returns:
    
    state transition descriptor
  - startTimerWithFixedDelay
```
public void startTimerWithFixedDelay(java.lang.String name,
                                     java.lang.Object msg,
                                     java.time.Duration delay)
```
    Schedules a message to be sent repeatedly to the self actor with a fixed delay between messages.
    It will not compensate the delay between messages if scheduling is delayed longer than specified for some reason. The delay between sending of subsequent messages will always be (at least) the given delay.
    In the long run, the frequency of messages will generally be slightly lower than the reciprocal of the specified delay.
    Each timer has a name and if a new timer with same name is started the previous is cancelled. It is guaranteed that a message from the previous timer is not received, even if it was already enqueued in the mailbox when the new timer was started.
  - startTimerAtFixedRate
```
public void startTimerAtFixedRate(java.lang.String name,
                                  java.lang.Object msg,
                                  java.time.Duration interval)
```
    Schedules a message to be sent repeatedly to the self actor with a given frequency.
    It will compensate the delay for a subsequent message if the sending of previous message was delayed more than specified. In such cases, the actual message interval will differ from the interval passed to the method.
    If the execution is delayed longer than the interval, the subsequent message will be sent immediately after the prior one. This also has the consequence that after long garbage collection pauses or other reasons when the JVM was suspended all "missed" messages will be sent when the process wakes up again.
    In the long run, the frequency of messages will be exactly the reciprocal of the specified interval.
    Warning: startTimerAtFixedRate can result in bursts of scheduled messages after long garbage collection pauses, which may in worst case cause undesired load on the system. Therefore startTimerWithFixedDelay is often preferred.
    Each timer has a name and if a new timer with same name is started the previous is cancelled. It is guaranteed that a message from the previous timer is not received, even if it was already enqueued in the mailbox when the new timer was started.
  - startSingleTimer
```
public void startSingleTimer(java.lang.String name,
                             java.lang.Object msg,
                             java.time.Duration delay)
```
    Start a timer that will send msg once to the self actor after the given delay.
    Each timer has a name and if a new timer with same name is started the previous is cancelled. It is guaranteed that a message from the previous timer is not received, even if it was already enqueued in the mailbox when the new timer was started.
  - setTimer
```
public final void setTimer(java.lang.String name,
                           java.lang.Object msg,
                           scala.concurrent.duration.FiniteDuration timeout)
```
    Deprecated.
    Use startSingleTimer instead. Since 2.6.0.
    
    Schedule named timer to deliver message after given delay, possibly repeating. Any existing timer with the same name will automatically be canceled before adding the new timer.
    
    Parameters:
    
    name - identifier to be used with cancelTimer()
    
    msg - message to be delivered
    
    timeout - delay of first message delivery and between subsequent messages
  - setTimer
```
public final void setTimer(java.lang.String name,
                           java.lang.Object msg,
                           java.time.Duration timeout)
```
    Deprecated.
    Use startSingleTimer instead. Since 2.6.0.
    
    Schedule named timer to deliver message after given delay, possibly repeating. Any existing timer with the same name will automatically be canceled before adding the new timer.
    
    Parameters:
    
    name - identifier to be used with cancelTimer()
    
    msg - message to be delivered
    
    timeout - delay of first message delivery and between subsequent messages
  - setTimer
```
public final void setTimer(java.lang.String name,
                           java.lang.Object msg,
                           java.time.Duration timeout,
                           boolean repeat)
```
    Deprecated.
    Use startSingleTimer, startTimerWithFixedDelay or startTimerAtFixedRate instead. This has the same semantics as startTimerAtFixedRate, but startTimerWithFixedDelay is often preferred. Since 2.6.0.
    
    Schedule named timer to deliver message after given delay, possibly repeating. Any existing timer with the same name will automatically be canceled before adding the new timer.
    
    Parameters:
    
    name - identifier to be used with cancelTimer()
    
    msg - message to be delivered
    
    timeout - delay of first message delivery and between subsequent messages
    
    repeat - send once if false, scheduleAtFixedRate if true
  - Normal
```
public FSM.Reason Normal()
```
    Default reason if calling stop().
  - Shutdown
```
public FSM.Reason Shutdown()
```
    Reason given when someone was calling system.stop(fsm) from outside; also applies to Stop supervision directive.

Class AbstractFSM<S,​D>

Nested Class Summary

Nested classes/interfaces inherited from interface akka.actor.Actor

Nested classes/interfaces inherited from interface akka.actor.FSM

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface akka.actor.Actor

Methods inherited from interface akka.actor.ActorLogging

Methods inherited from interface akka.actor.FSM

Methods inherited from interface akka.routing.Listeners

Constructor Detail

AbstractFSM

Method Detail

NullFunction

Event

StopEvent

$minus$greater

StateTimeout

akka$actor$FSM$_setter_$Event_$eq

akka$actor$FSM$_setter_$StopEvent_$eq

akka$actor$FSM$_setter_$StateTimeout_$eq

listeners

akka$routing$Listeners$_setter_$listeners_$eq

context

self

akka$actor$Actor$_setter_$context_$eq

akka$actor$Actor$_setter_$self_$eq

getContext

getSelf

getSender

when

when

when

when

startWith

startWith

startWith

onTransition

onTransition

whenUnhandled

onTermination

matchEvent

matchEvent

matchEvent

matchEvent

matchEvent

matchEvent

matchEvent

matchEventEquals

matchEventEquals

matchAnyEvent

matchState

matchState

matchStop

matchStop

matchStop

matchData

matchData

goTo

startTimerWithFixedDelay

startTimerAtFixedRate

startSingleTimer

setTimer

setTimer

setTimer

Normal

Shutdown

Class AbstractFSM<S,D>