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}