001/* Copyright (C) 2013 TU Dortmund
002 * This file is part of AutomataLib, http://www.automatalib.net/.
003 * 
004 * AutomataLib is free software; you can redistribute it and/or
005 * modify it under the terms of the GNU Lesser General Public
006 * License version 3.0 as published by the Free Software Foundation.
007 * 
008 * AutomataLib is distributed in the hope that it will be useful,
009 * but WITHOUT ANY WARRANTY; without even the implied warranty of
010 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
011 * Lesser General Public License for more details.
012 * 
013 * You should have received a copy of the GNU Lesser General Public
014 * License along with AutomataLib; if not, see
015 * http://www.gnu.de/documents/lgpl.en.html.
016 */
017package net.automatalib.automata.transout.impl;
018
019import java.util.List;
020
021import net.automatalib.automata.base.fast.FastMutableDet;
022import net.automatalib.automata.transout.MutableMooreMachine;
023import net.automatalib.automata.transout.abstractimpl.AbstractMooreMachine;
024import net.automatalib.automata.transout.abstractimpl.AbstractTransOutAutomaton;
025import net.automatalib.words.Alphabet;
026import net.automatalib.words.Word;
027
028
029/**
030 * A fast implementation of a Moore automaton.
031 * 
032 * @author Malte Isberner <malte.isberner@cs.uni-dortmund.de>
033 *
034 * @param <I> input symbol class.
035 * @param <O> output symbol class.
036 */
037public final class FastMoore<I, O> extends FastMutableDet<FastMooreState<O>, I, FastMooreState<O>, O, Void>
038                implements MutableMooreMachine<FastMooreState<O>, I, FastMooreState<O>, O> {
039
040        public FastMoore(Alphabet<I> alphabet) {
041                super(alphabet);
042        }
043
044
045        /*
046         * (non-Javadoc)
047         * @see de.ls5.ts.TransitionSystem#getSuccessor(java.lang.Object)
048         */
049        @Override
050        public FastMooreState<O> getSuccessor(FastMooreState<O> transition) {
051                return transition;
052        }
053
054        /*
055         * (non-Javadoc)
056         * @see de.ls5.automata.transout.TransitionOutputAutomaton#trace(java.lang.Iterable)
057         */
058        @Override
059        public void trace(Iterable<I> input, List<O> output) {
060                AbstractTransOutAutomaton.trace(this, input, output);
061        }
062
063        /*
064         * (non-Javadoc)
065         * @see de.ls5.automata.transout.TransitionOutputAutomaton#trace(java.lang.Object, java.lang.Iterable)
066         */
067        @Override
068        public void trace(FastMooreState<O> state, Iterable<I> input, List<O> output) {
069                AbstractTransOutAutomaton.trace(this, state, input, output);
070        }
071
072        /*
073         * (non-Javadoc)
074         * @see de.ls5.automata.features.TransitionOutput#getTransitionOutput(java.lang.Object)
075         */
076        @Override
077        public O getTransitionOutput(FastMooreState<O> transition) {
078                return AbstractMooreMachine.getTransitionOutput(this, transition);
079        }
080
081        /*
082         * (non-Javadoc)
083         * @see de.ls5.automata.features.StateOutput#getStateOutput(java.lang.Object)
084         */
085        @Override
086        public O getStateOutput(FastMooreState<O> state) {
087                return state.getOutput();
088        }
089
090        /*
091         * (non-Javadoc)
092         * @see de.ls5.automata.MutableAutomaton#setStateProperty(java.lang.Object, java.lang.Object)
093         */
094        @Override
095        public void setStateProperty(FastMooreState<O> state, O property) {
096                AbstractMooreMachine.setStateProperty(this, state, property);
097        }
098
099        /*
100         * (non-Javadoc)
101         * @see de.ls5.automata.MutableAutomaton#setTransitionProperty(java.lang.Object, java.lang.Object)
102         */
103        @Override
104        public void setTransitionProperty(FastMooreState<O> transition, Void property) {
105                AbstractMooreMachine.setTransitionProperty(this, transition, property);
106        }
107        
108        /*
109         * (non-Javadoc)
110         * @see de.ls5.automata.MutableAutomaton#createTransition(java.lang.Object, java.lang.Object)
111         */
112        @Override
113        public FastMooreState<O> createTransition(FastMooreState<O> successor,
114                        Void properties) {
115                return successor;
116        }
117
118        /*
119         * (non-Javadoc)
120         * @see de.ls5.automata.MutableAutomaton#copyTransition(java.lang.Object, java.lang.Object)
121         */
122        @Override
123        public FastMooreState<O> copyTransition(FastMooreState<O> trans, FastMooreState<O> succ) {
124                return AbstractMooreMachine.copyTransition(this, trans, succ);
125        }
126
127        /*
128         * (non-Javadoc)
129         * @see de.ls5.automata.features.MutableStateOutput#setStateOutput(java.lang.Object, java.lang.Object)
130         */
131        @Override
132        public void setStateOutput(FastMooreState<O> state, O output) {
133                state.setOutput(output);
134        }
135
136        /*
137         * (non-Javadoc)
138         * @see de.ls5.automata.base.fast.FastMutableDet#createState(java.lang.Object)
139         */
140        @Override
141        protected FastMooreState<O> createState(O property) {
142                return new FastMooreState<O>(inputAlphabet.size(), property);
143        }
144
145        /*
146         * (non-Javadoc)
147         * @see de.ls5.ts.UniversalTransitionSystem#getStateProperty(java.lang.Object)
148         */
149        @Override
150        public O getStateProperty(FastMooreState<O> state) {
151                return AbstractMooreMachine.getStateProperty(this, state);
152        }
153
154        /*
155         * (non-Javadoc)
156         * @see de.ls5.ts.UniversalTransitionSystem#getTransitionProperty(java.lang.Object)
157         */
158        @Override
159        public Void getTransitionProperty(FastMooreState<O> transition) {
160                return AbstractMooreMachine.getTransitionProperty(this, transition);
161        }
162
163
164        /*
165         * (non-Javadoc)
166         * @see de.ls5.automata.features.SODetOutputAutomaton#computeSuffixOutput(java.lang.Iterable, java.lang.Iterable)
167         */
168        @Override
169        public Word<O> computeSuffixOutput(Iterable<I> prefix, Iterable<I> suffix) {
170                return AbstractTransOutAutomaton.computeSuffixOutput(this, prefix, suffix);
171        }
172
173
174        /*
175         * (non-Javadoc)
176         * @see de.ls5.automata.features.OutputAutomaton#computeOutput(java.lang.Iterable)
177         */
178        @Override
179        public Word<O> computeOutput(Iterable<I> input) {
180                return AbstractTransOutAutomaton.computeOutput(this, input);
181        }
182
183
184        @Override
185        public O getOutput(FastMooreState<O> state, I input) {
186                return AbstractTransOutAutomaton.getOutput(this, state, input);
187        }
188
189}