de.scravy.machina.AbstractStateMachine Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of machina Show documentation
A finite state machine library that features true stateless state machines.
There is a newer version: 1.3.1
// Generated by delombok at Mon May 25 16:22:43 CEST 2015
package de.scravy.machina;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import de.scravy.machina.StateMachines.OutputFormat;

/**
 * INTERNAL
 */
abstract class AbstractStateMachine implements StateMachine {
  private static final Logger LOGGER = LoggerFactory.getLogger(StateMachine.class);
  private final S initial;
  private final Class contextClass;
  private final Class stateClass;
  private final Class eventClass;
  private final Class eventTypeClass;
  private final TransitionMap transitions;
  private final EventTypeClassifier eventTypeClassifier;
  private final List> transitionListeners;

  AbstractStateMachine(final S initial, final Iterable> transitionList, final Class states, final Class events, final Class eventTypes, final Class contextClass, final EventTypeClassifier eventTypeClassifier, final Collection> listeners) {
    this(initial, contextClass, states, events, eventTypes, new TransitionMap(transitionList), eventTypeClassifier, new ArrayList<>(listeners));
  }

  public RunResult run(final Iterable events, final C context) {
    RunResult currentState = new RunResult<>(this.initial, context);
    for (final E ev : events) {
      currentState = run(currentState.getFirst(), ev, currentState.getSecond());
    }
    return currentState;
  }

  @SuppressWarnings("unchecked")
  public RunResult run(final S currentState, final E event, final C context) {
    final T eventType;
    try {
      eventType = this.eventTypeClassifier.classify(event);
    } catch (final Exception exc) {
      throw new EventTypeClassifierException(currentState, event, context, exc);
    }
    final S next;
    try {
      next = this.transitions.getNextStateFor(currentState, event, eventType, context);
    } catch (final Exception exc) {
      throw new StateMachineException(currentState, event, context, exc);
    }
    if (next == null) {
      throw new DeadEndException(currentState, event, context);
    }
    final C contextAfterExit;
    if (currentState instanceof StateWithExitHandler) {
      try {
        contextAfterExit = ((StateWithExitHandler)next).onExit(event, context);
      } catch (final Exception exc) {
        throw new StateHandlerException(currentState, event, context, exc);
      }
    } else {
      contextAfterExit = context;
    }
    for (final TransitionListener listener : this.transitionListeners) {
      try {
        listener.onTransition(currentState, eventType, next, event, contextAfterExit);
      } catch (final Exception exc) {
        LOGGER.warn("A TransitionListener throwed an exception.", exc);
      }
    }
    if (next instanceof StateWithEnterHandler) {
      try {
        final C contextAfterEnter = ((StateWithEnterHandler)next).onEnter(event, contextAfterExit);
        return new RunResult<>(next, contextAfterEnter);
      } catch (final Exception exc) {
        throw new StateHandlerException(currentState, event, contextAfterExit, exc);
      }
    }
    return new RunResult(next, context);
  }

  public S run(final Iterable events) {
    return run(events, null).getFirst();
  }

  public S run(final S current, final E event) {
    return run(current, event, null).getFirst();
  }

  @Override
  public List> getTransitions() {
    return this.transitions.getTransitions();
  }

  @Override
  public S getInitialState() {
    return this.initial;
  }

  @Override
  public String toString() {
    return StateMachines.toString(this, OutputFormat.Graphviz);
  }

  @SuppressWarnings("all")
  @javax.annotation.Generated("lombok")
  private AbstractStateMachine(final S initial, final Class contextClass, final Class stateClass, final Class eventClass, final Class eventTypeClass, final TransitionMap transitions, final EventTypeClassifier eventTypeClassifier, final List> transitionListeners) {
    this.initial = initial;
    this.contextClass = contextClass;
    this.stateClass = stateClass;
    this.eventClass = eventClass;
    this.eventTypeClass = eventTypeClass;
    this.transitions = transitions;
    this.eventTypeClassifier = eventTypeClassifier;
    this.transitionListeners = transitionListeners;
  }

  @SuppressWarnings("all")
  @javax.annotation.Generated("lombok")
  public Class getContextClass() {
    return this.contextClass;
  }

  @SuppressWarnings("all")
  @javax.annotation.Generated("lombok")
  public Class getStateClass() {
    return this.stateClass;
  }

  @SuppressWarnings("all")
  @javax.annotation.Generated("lombok")
  public Class getEventClass() {
    return this.eventClass;
  }

  @SuppressWarnings("all")
  @javax.annotation.Generated("lombok")
  public Class getEventTypeClass() {
    return this.eventTypeClass;
  }
}