A programmable Finite State Machine implementation. : Algorithms « Collections Data Structure « Java






A programmable Finite State Machine implementation.

       
// $Id: FSM.java 12 2009-11-09 22:58:47Z gabe.johnson $

//package org.six11.util.data;

//import org.six11.util.Debug;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

/**
 * A programmable Finite State Machine implementation. To use this class,
 * establish any number of states with the 'addState' method. Next, add some
 * FSM.Transition objects (the Transition class is designed to be used as an
 * superclass for your anonymous implementation). Each Transition object has two
 * useful methods that can be defined by your implementation: doBeforeTransition
 * and doAfterTransition. To drive your FSM, simply give it events using the
 * addEvent method with the name of an event. If there is an appropriate
 * transition for the current state, the transition's doBefore/doAfter methods
 * are called and the FSM is put into the new state. It is legal (and highly
 * useful) for the start/end states of a transition to be the same state.
 **/
public class FSM { // This class implements a Flying Spaghetti Monster

  protected String name;
  protected String currentState;
  protected Map<String, State> states;
  protected List<ChangeListener> changeListeners;
  protected boolean debug;

  /**
   * Create a blank FSM with the given name (which is arbitrary).
   */
  public FSM(String name) {
    this.name = name;
    this.states = new HashMap<String, State>();
    this.currentState = null;
    this.changeListeners = new ArrayList<ChangeListener>();
  }

  /**
   * Turn debugging on/off.
   */
  public void setDebugMode(boolean debug) {
    this.debug = debug;
  }

  /**
   * Report the current state of the finite state machine.
   */
  public String getState() {
    return currentState;
  }

  /**
   * Adds a new state with no entry or exit code.
   */
  public void addState(String state) {
    addState(state, null, null, null);
  }

  /**
   * Establish a new state the FSM is aware of. If the FSM does not currently
   * have any states, this state becomes the current, initial state. This is
   * the only way to put the FSM into an initial state.
   * 
   * The entryCode, exitCode, and alwaysRunCode are Runnables that the FSM
   * executes during the course of a transition. entryCode and exitCode are
   * run only if the transition is between two distinct states (i.e. A->B
   * where A != B). alwaysRunCode is executed even if the transition is
   * re-entrant (i.e. A->B where A = B).
   **/
  public void addState(String state, Runnable entryCode, Runnable exitCode,
      Runnable alwaysRunCode) {
    boolean isInitial = (states.size() == 0);
    if (!states.containsKey(state)) {
      states.put(state, new State(entryCode, exitCode, alwaysRunCode));
    }
    if (isInitial) {
      setState(state);
    }
  }

  public void setStateEntryCode(String state, Runnable entryCode) {
    states.get(state).entryCode = entryCode;
  }

  public void setStateExitCode(String state, Runnable exitCode) {
    states.get(state).exitCode = exitCode;
  }

  public void setStateAlwaysRunCode(String state, Runnable alwaysRunCode) {
    states.get(state).alwaysRunCode = alwaysRunCode;
  }

  /**
   * There are cases where a state is meant to be transitional, and the FSM
   * should always immediately transition to some other state. In those cases,
   * use this method to specify the start and end states. After the startState
   * has fully transitioned (and any change events have been fired) the FSM
   * will check to see if there is another state that the FSM should
   * automatically transition to. If there is one, addEvent(endState) is
   * called.
   * 
   * Note: this creates a special transition in the lookup table called
   * "(auto)".
   */
  public void setAutoTransition(String startState, String endState) {
    // if (debug) {
    // Debug.out("FSM", "Establishing auto transition for " + startState +
    // " -> " + endState);
    // }
    states.get(startState).autoTransitionState = endState;
    addTransition(new Transition("(auto)", startState, endState));
  }

  /**
   * Sets the current state without following a transition. This will cause a
   * change event to be fired.
   */
  public void setState(String state) {
    setState(state, true);
  }

  /**
   * Sets the current state without followign a transition, and optionally
   * causing a change event to be triggered. During state transitions (with
   * the 'addEvent' method), this method is used with the triggerEvent
   * parameter as false.
   * 
   * The FSM executes non-null runnables according to the following logic,
   * given start and end states A and B:
   * 
   * <ol>
   * <li>If A and B are distinct, run A's exit code.</li>
   * <li>Record current state as B.</li>
   * <li>Run B's "alwaysRunCode".</li>
   * <li>If A and B are distinct, run B's entry code.</li>
   * </ol>
   */
  public void setState(String state, boolean triggerEvent) {
    boolean runExtraCode = !state.equals(currentState);
    if (runExtraCode && currentState != null) {
      states.get(currentState).runExitCode();
    }
    currentState = state;
    states.get(currentState).runAlwaysCode();
    if (runExtraCode) {
      states.get(currentState).runEntryCode();
    }
    if (triggerEvent) {
      fireChangeEvent();
    }
  }

  /**
   * Establish a new transition. You might use this method something like
   * this:
   * 
   * fsm.addTransition(new FSM.Transition("someEvent", "firstState",
   * "secondState") { public void doBeforeTransition() {
   * System.out.println("about to transition..."); } public void
   * doAfterTransition() { fancyOperation(); } });
   */
  public void addTransition(Transition trans) {
    State st = states.get(trans.startState);
    if (st == null) {
      throw new NoSuchElementException("Missing state: "
          + trans.startState);
    }
    st.addTransition(trans);
  }

  /**
   * Add a change listener -- this is a standard java change listener and is
   * only used to report changes that have already happened. ChangeEvents are
   * only fired AFTER a transition's doAfterTransition is called.
   */
  public void addChangeListener(ChangeListener cl) {
    if (!changeListeners.contains(cl)) {
      changeListeners.add(cl);
    }
  }

  /**
   * Feed the FSM with the named event. If the current state has a transition
   * that responds to the given event, the FSM will performed the transition
   * using the following steps, assume start and end states are A and B:
   * 
   * <ol>
   * <li>Execute the transition's "doBeforeTransition" method</li>
   * <li>Run fsm.setState(B) -- see docs for that method</li>
   * <li>Execute the transition's "doAfterTransition" method</li>
   * <li>Fire a change event, notifying interested observers that the
   * transition has completed.</li>
   * <li>Now firmly in state B, see if B has a third state C that we must
   * automatically transition to via addEvent(C).</li>
   * </ol>
   */
  public void addEvent(String evtName) {
    State state = states.get(currentState);
    if (state.transitions.containsKey(evtName)) {
      Transition trans = state.transitions.get(evtName);
      // if (debug) {
      // Debug.out("FSM", "Event: " + evtName + ", " + trans.startState +
      // " --> " + trans.endState);
      // }
      trans.doBeforeTransition();
      setState(trans.endState, false);
      trans.doAfterTransition();
      fireChangeEvent();
      if (states.get(trans.endState).autoTransitionState != null) {
        // if (debug) {
        // Debug.out("FSM", "Automatically transitioning from " +
        // trans.endState + " to "
        // + states.get(trans.endState).autoTransitionState);
        // }
        addEvent("(auto)");
      }
    }
  }

  /**
   * Fire a change event to registered listeners.
   */
  protected void fireChangeEvent() {
    ChangeEvent changeEvent = new ChangeEvent(this);
    for (ChangeListener cl : changeListeners) {
      cl.stateChanged(changeEvent);
    }
  }

  /**
   * Represents a state with some number of associated transitions.
   */
  private static class State {
    Map<String, Transition> transitions;
    String autoTransitionState;
    Runnable entryCode;
    Runnable exitCode;
    Runnable alwaysRunCode;

    State(Runnable entryCode, Runnable exitCode, Runnable alwaysRunCode) {
      autoTransitionState = null;
      transitions = new HashMap<String, Transition>();
      this.entryCode = entryCode;
      this.exitCode = exitCode;
      this.alwaysRunCode = alwaysRunCode;
    }

    public void addTransition(Transition trans) {
      transitions.put(trans.evtName, trans);
    }

    public void runEntryCode() {
      if (entryCode != null) {
        entryCode.run();
      }
    }

    public void runExitCode() {
      if (exitCode != null) {
        exitCode.run();
      }
    }

    public void runAlwaysCode() {
      if (alwaysRunCode != null) {
        alwaysRunCode.run();
      }
    }
  }

  /**
   * Create a new transition. See the documentation for addEvent and
   * addTransition in FSM.
   */
  public static class Transition {
    String evtName;
    String startState;
    String endState;

    /**
     * Create a transition object that responds to the given event when in
     * the given startState, and puts the FSM into the endState provided.
     */
    public Transition(String evtName, String startState, String endState) {
      this.evtName = evtName;
      this.startState = startState;
      this.endState = endState;
    }

    /**
     * Override this to have FSM execute code immediately before following a
     * state transition.
     */
    public void doBeforeTransition() {
    }

    /**
     * Override this to have FSM execute code immediately after following a
     * state transition.
     */
    public void doAfterTransition() {
    }
  }
}

   
    
    
    
    
    
    
  








Related examples in the same category

1.AnagramsAnagrams
2.Hanoi puzzleHanoi puzzle
3.FibonacciFibonacci
4.Sieve Sieve
5.Find connections using a depth-first searchFind connections using a depth-first search
6.Find connections using hill climbing.
7.Find optimal solution using least-cost
8.Find the lost keysFind the lost keys
9.Compute the area of a triangle using Heron's FormulaCompute the area of a triangle using Heron's Formula
10.Compute prime numbers
11.Print a table of fahrenheit and celsius temperatures 1
12.Print a table of fahrenheit and celsius temperatures 2
13.Print a table of Fahrenheit and Celsius temperatures 3Print a table of Fahrenheit and Celsius temperatures 3
14.Soundex - the Soundex Algorithm, as described by KnuthSoundex - the Soundex Algorithm, as described by Knuth
15.An extendable Graph datastructure.
16.Utilities for flop (floating-point operation) counting.
17.LU Decomposition
18.Reverse Polish Notation
19.Permutator test
20.implements the LZF lossless data compression algorithm
21.Linear Interpolation
22.Utility class for generating the k-subsets of the numbers 0 to n
23.VersionVersion