source: trunk/src/org/expeditee/core/FSM.java@ 1097

package org.expeditee.core;

import java.util.ArrayList;
import java.util.List;

public class FSM {

        private int _currentState;
        private List<Object> _transitions;
        private List<Integer> _nextTrueStates;
        private List<Integer> _nextFalseStates;
        private List<Boolean> _finalStates;
        private boolean _inconsistent;
        
        public FSM()
        {
                _transitions = new ArrayList<Object>();
                _nextTrueStates = new ArrayList<Integer>();
                _nextFalseStates = new ArrayList<Integer>();
                _finalStates = new ArrayList<Boolean>();
                
                configureState(0, null, 0, 0, false);
                reset();
        }
        
        /**
         * Resets the DFSM to its initial state.
         */
        public void reset()
        {
                _currentState = 0;
                _inconsistent = false;
        }
        
        /**
         * Gets the current state of the DFSM.
         */
        public int currentState()
        {
                return _currentState;
        }
        
        /**
         * Whether the DFSM is in a consistent state. May be false if a state has been incorrectly
         * configured causing a transition into unconfigured territory.
         */
        public boolean isConsistent()
        {
                return !_inconsistent;
        }
        
        /**
         * Edits the configuration of a given state.
         * 
         * @param state The state to configure.
         * @param transition The object to use for comparison to determine the next state.
         * @param nextTrueState The next state to go to if the input is equal to the transition object.
         * @param nextFalseState The next state to go to if the input is not equal to the transition object.
         * @param isFinalState Whether this state is a final state.
         */
        public void configureState(int state, Object transition, int nextTrueState, int nextFalseState, boolean isFinalState)
        {
                if (state < 0 || nextTrueState < 0 || nextFalseState < 0) return;
                
                while (state > _transitions.size()) {
                        _transitions.add(null);
                        _nextTrueStates.add(null);
                        _nextFalseStates.add(null);
                        _finalStates.add(null);
                }
                
                _transitions.set(state, transition);
                _nextTrueStates.set(state, nextTrueState);
                _nextFalseStates.set(state, nextFalseState);
                _finalStates.set(state, isFinalState);
        }
        
        /**
         * Moves the DFSM to a new state based on comparing the input object to the transition
         * object for the current state.
         * 
         * @param input The input object to compare to.
         */
        public void input(Object input)
        {
                // Can't do anything if we are inconsistent
                if (_inconsistent) return;
                
                // Get the transition object for the current state
                Object transition = _transitions.get(_currentState);
                
                // Work out whether the input matches the transition object
                boolean result;
                if (transition == null) {
                        result = input == null;
                } else {
                        result = transition.equals(input);
                }
                
                // Work out which state to go to next
                Integer nextState;
                if (result) {
                        nextState = _nextTrueStates.get(_currentState);
                } else {
                        nextState = _nextFalseStates.get(_currentState);
                }
                
                // If there is no next state, we are inconsistent
                if (nextState == null) {
                        _inconsistent = true;
                        return;
                }
                
                // Go to the next state
                _currentState = nextState;
        }
        
        /**
         * Whether or not this DFSM is currently in a final state.
         */
        public boolean isFinalState()
        {
                Boolean finalState = _finalStates.get(_currentState);
                return !_inconsistent && finalState != null && finalState.booleanValue();
        }
        
        
}