NaiveAutomatonSpecification.java

package pl.edu.amu.wmi.daut.base;

import java.util.List;
import java.util.LinkedList;

/**
 * Nieefektywne, przykładowe ukonkretnienie klasy abstrakcyjnej
 * AutomatonSpecification.
 *
 * Wszystkie przejścia są przechowywane na jednej liście.
 */
public class NaiveAutomatonSpecification extends AutomatonSpecification {

    /**
     * Stan to po prostu pusta klasa. Liczy się tylko tożsamość instancji.
     *
     * Dlaczego ta klasa jest zadeklarowana jako statyczna?
     * Odpowiedź na stronie: http://download.oracle.com/javase/tutorial/java/javaOO/nested.html
     */
    static class NaiveState implements State {
        /**
         * Konstruuje stan.
         */
        public NaiveState() {
        }
    }

    /**
     * Pomocnicza klasa reprezentująca przejście.
     */
    private static class NaiveTransition {
        /**
         * Konstruuje przejście.
         */
        public NaiveTransition(NaiveState aFrom, NaiveState aTo, TransitionLabel aTransitionLabel) {
            from = aFrom;
            to = aTo;
            transitionLabel = aTransitionLabel;
        }

        /**
         * Zwraca stan źródłowy.
         */
        public NaiveState getSourceState() {
            return from;
        }

        /**
         * Zwraca stan docelowy.
         */
        public NaiveState getTargetState() {
            return to;
        }

        /**
         * Zwraca etykietę przejścia.
         */
        public TransitionLabel getTransitionLabel() {
            return transitionLabel;
        }

        private NaiveState from;
        private NaiveState to;
        private TransitionLabel transitionLabel;
    }

    @Override
    public NaiveState addState() {
        NaiveState newState = new NaiveState();
        allStates.add(newState);
        return newState;
    }

    @Override
    public void addTransition(State from, State to, TransitionLabel transitionLabel) {
        transitions.add(new NaiveTransition((NaiveState) from, (NaiveState) to, transitionLabel));
    }

    @Override
    public void markAsInitial(State state) {
        initialState = (NaiveState) state;
    }

    @Override
    public void markAsFinal(State state) {
        finalStates.add((NaiveState) state);
    }

    @Override
    public void unmarkAsFinalState(State state) {
        finalStates.remove((NaiveState) state);
    }

    @Override
    public List<State> allStates() {
        return allStates;
    }

    @Override
    public List<OutgoingTransition> allOutgoingTransitions(State from) {
        LinkedList<OutgoingTransition> returnedList = new LinkedList<OutgoingTransition>();

        for (NaiveTransition transition : transitions) {
            if (transition.getSourceState() == from)
                returnedList.add(convertNaiveTransitionToOutgoingTransition(transition));
        }

        return returnedList;
    }

    @Override
    public State getInitialState() {
        return initialState;
    }

    @Override
    public boolean isFinal(State state) {
        for (NaiveState someState : finalStates) {
            if (someState == state)
                return true;
        }

        return false;
    }

    private OutgoingTransition convertNaiveTransitionToOutgoingTransition(
        NaiveTransition transition) {

        return new OutgoingTransition(
            transition.getTransitionLabel(),
            transition.getTargetState());
    }

    private LinkedList<State> allStates = new LinkedList<State>();
    private LinkedList<NaiveTransition> transitions = new LinkedList<NaiveTransition>();
    private NaiveState initialState;
    private LinkedList<NaiveState> finalStates = new LinkedList<NaiveState>();
}