diff --git a/alib2/src/automaton/AutomatonFromXMLParser.cpp b/alib2/src/automaton/AutomatonFromXMLParser.cpp
index e5bbbf96f363146e7186813e50fa623275186639..4ac63b8ffbcb5a8b687a8706cd78030c4ce97ccf 100644
--- a/alib2/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2/src/automaton/AutomatonFromXMLParser.cpp
@@ -160,10 +160,8 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseInp
 	popToken(input, sax::Token::START_ELEMENT, tagName);
 
 	std::variant<string::Epsilon, alphabet::Symbol> result;
-	if (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	if (isTokenType(input, sax::Token::CHARACTER)) {
 		result.set<alphabet::Symbol>(alphabet::Symbol(popTokenData(input, sax::Token::CHARACTER)));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
 	} else if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
 		result.set<string::Epsilon>(string::Epsilon());
 		input.pop_front();
diff --git a/alib2/src/automaton/AutomatonToXMLComposer.cpp b/alib2/src/automaton/AutomatonToXMLComposer.cpp
index 8e05cfa173d207905c3edcedcb19978eb34c72f9..c5fd4d68b19313df5eee06612dc3dad4592aa017 100644
--- a/alib2/src/automaton/AutomatonToXMLComposer.cpp
+++ b/alib2/src/automaton/AutomatonToXMLComposer.cpp
@@ -82,6 +82,9 @@ void AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const std::v
 	if(symbol.is<string::Epsilon>()) {
 		out.push_back(sax::Token("epsilon", sax::Token::START_ELEMENT));
 		out.push_back(sax::Token("epsilon", sax::Token::END_ELEMENT));
+	} else if(symbol.get<alphabet::Symbol>() == alphabet::Blank::BLANK) {
+		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::END_ELEMENT));
 	} else {
 		out.push_back(sax::Token(symbol.get<alphabet::Symbol>().getSymbol(), sax::Token::CHARACTER));
 	}
@@ -89,9 +92,14 @@ void AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const std::v
 }
 
 void AutomatonToXMLComposer::printSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
-	out.push_back(sax::Token(symbol.getSymbol(), sax::Token::CHARACTER));
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	if(symbol == alphabet::Blank::BLANK) {
+		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
+	} else {
+		out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+		out.push_back(sax::Token(symbol.getSymbol(), sax::Token::CHARACTER));
+		out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	}
 }
 
 void AutomatonToXMLComposer::printShift(std::list<sax::Token>& out, const Shift& shift, std::string tagName) {
diff --git a/alib2/src/automaton/AutomatonToXMLComposer.h b/alib2/src/automaton/AutomatonToXMLComposer.h
index 7bda0daf6da436fc5a2e5cbb6cc3a93e6c21dd2c..c8a075ae69d574147489dee854253d4f38cc1aeb 100644
--- a/alib2/src/automaton/AutomatonToXMLComposer.h
+++ b/alib2/src/automaton/AutomatonToXMLComposer.h
@@ -11,6 +11,7 @@
 #include <string>
 #include "UnknownAutomaton.h"
 #include "../sax/Token.h"
+#include "../alphabet/Blank.h"
 
 namespace automaton {
 
diff --git a/alib2/src/automaton/FSM/DFA.cpp b/alib2/src/automaton/FSM/DFA.cpp
index b5608b0bf2a66069cc3ec70fb5162953420282c2..45e75ff3755c7ac3f0d374f2672b72bc164f313d 100644
--- a/alib2/src/automaton/FSM/DFA.cpp
+++ b/alib2/src/automaton/FSM/DFA.cpp
@@ -11,12 +11,6 @@
 
 namespace automaton {
 
-void DFA::addInputSymbol(const alphabet::Symbol& symbol) {
-	std::pair<std::set<alphabet::Symbol>::iterator, bool> ret = inputAlphabet.insert(symbol);
-	if (!ret.second)
-		throw AutomatonException("Input symbol \"" + symbol.getSymbol() + "\" already exists.");
-}
-
 void DFA::removeState(const State& state) {
 	if (initialStates.find(state) != initialStates.end()) {
 		throw AutomatonException("State \"" + state.getName() + "\" is initial state.");
diff --git a/alib2/src/automaton/FSM/DFA.h b/alib2/src/automaton/FSM/DFA.h
index 52ba97db8701f1a5ea9d4d99257ccdfd399444a9..060854fd3339f9d53fc7645a8e4e202857199a8f 100644
--- a/alib2/src/automaton/FSM/DFA.h
+++ b/alib2/src/automaton/FSM/DFA.h
@@ -9,7 +9,7 @@
 #define DFA_H_
 
 #include <map>
-#include "../Automaton.h"
+#include "FSM.h"
 #include "../State.h"
 #include "../../alphabet/Symbol.h"
 
@@ -19,15 +19,10 @@ namespace automaton {
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class DFA : public Automaton {
+class DFA : public FSM {
 protected:
 	std::map<std::pair<State, alphabet::Symbol>, State> transitions;
 public:
-	/**
-	 * @copydoc Automaton::addInputSymbol(const Symbol&)
-	 */
-	virtual void addInputSymbol(const alphabet::Symbol& symbol);
-
 	/**
 	 * @copydoc Automaton::removeState(const State&)
 	 */
diff --git a/alib2/src/automaton/FSM/EpsilonNFA.cpp b/alib2/src/automaton/FSM/EpsilonNFA.cpp
index 9d6aba7e2e79fe827abcffb3a646f35e3ba35691..42abf2de12346dd287ba6d9d387e220fabfe78c8 100644
--- a/alib2/src/automaton/FSM/EpsilonNFA.cpp
+++ b/alib2/src/automaton/FSM/EpsilonNFA.cpp
@@ -11,12 +11,6 @@
 
 namespace automaton {
 
-void EpsilonNFA::addInputSymbol(const alphabet::Symbol& symbol) {
-	std::pair<std::set<alphabet::Symbol>::iterator, bool> ret = inputAlphabet.insert(symbol);
-	if (!ret.second)
-		throw AutomatonException("Input symbol \"" + symbol.getSymbol() + "\" already exists.");
-}
-
 void EpsilonNFA::removeState(const State& state) {
 	if (initialStates.find(state) != initialStates.end()) {
 		throw AutomatonException("State \"" + state.getName() + "\" is initial state.");
diff --git a/alib2/src/automaton/FSM/EpsilonNFA.h b/alib2/src/automaton/FSM/EpsilonNFA.h
index 97161275a364455bbb2282a5fe622a45689196fd..ed6202923b08474db60af6efb96d572a543f06ef 100644
--- a/alib2/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2/src/automaton/FSM/EpsilonNFA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include "../../std/variant.hpp"
-#include "../Automaton.h"
+#include "FSM.h"
 #include "../State.h"
 #include "../../alphabet/Symbol.h"
 #include "../../string/Epsilon.h"
@@ -21,15 +21,10 @@ namespace automaton {
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton with epsilon transitions.
  */
-class EpsilonNFA : public Automaton {
+class EpsilonNFA : public FSM {
 protected:
 	std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> > transitions;
 public:
-	/**
-	 * @copydoc Automaton::addInputSymbol(const Symbol&)
-	 */
-	virtual void addInputSymbol(const alphabet::Symbol& symbol);
-
 	/**
 	 * @copydoc Automaton::removeState(const State&)
 	 */
diff --git a/alib2/src/automaton/FSM/FSM.cpp b/alib2/src/automaton/FSM/FSM.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..18ff23b4717eb7e473cfa408dc35895b03696adb
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSM.cpp
@@ -0,0 +1,20 @@
+/*
+ * FSM.cpp
+ *
+ *  Created on: Mar 25, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "FSM.h"
+#include "../AutomatonException.h"
+#include <ostream>
+
+namespace automaton {
+
+void FSM::addInputSymbol(const alphabet::Symbol& symbol) {
+	std::pair<std::set<alphabet::Symbol>::iterator, bool> ret = inputAlphabet.insert(symbol);
+	if (!ret.second)
+		throw AutomatonException("Input symbol \"" + symbol.getSymbol() + "\" already exists.");
+}
+
+} /* namespace automaton */
diff --git a/alib2/src/automaton/FSM/FSM.h b/alib2/src/automaton/FSM/FSM.h
new file mode 100644
index 0000000000000000000000000000000000000000..ddf21a84a6b7b060c9d3471866156e3fbb2da057
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSM.h
@@ -0,0 +1,32 @@
+/*
+ * FSM.h
+ *
+ *  Created on: Mar 25, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef FSM_H_
+#define FSM_H_
+
+#include <map>
+#include "../Automaton.h"
+#include "../State.h"
+#include "../../alphabet/Symbol.h"
+
+namespace automaton {
+
+/**
+ * Represents Finite Automaton.
+ */
+class FSM : public Automaton {
+public:
+	/**
+	 * @copydoc Automaton::addInputSymbol(const Symbol&)
+	 */
+	virtual void addInputSymbol(const alphabet::Symbol& symbol);
+
+};
+
+} /* namespace automaton */
+
+#endif /* FSM_H_ */
diff --git a/alib2/src/automaton/FSM/FSMFromXMLParser.cpp b/alib2/src/automaton/FSM/FSMFromXMLParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..7a2597f149ed1d91372b56752e31adef89a6e48c
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSMFromXMLParser.cpp
@@ -0,0 +1,183 @@
+/*
+ * FSMFromXMLParser.cpp
+ *
+ *  Created on: Oct 12, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "FSMFromXMLParser.h"
+
+#include "../../sax/ParserException.h"
+#include "../../alphabet/Blank.h"
+
+namespace automaton {
+
+FSM* FSMFromXMLParser::parse(std::list<sax::Token> &input) {
+	if(isToken(input, sax::Token::START_ELEMENT, "EpsilonNFA"))
+		return new EpsilonNFA(parseEpsilonNFA(input));
+	else if(isToken(input, sax::Token::START_ELEMENT, "NFA"))
+		return new NFA(parseNFA(input));
+	else if(isToken(input, sax::Token::START_ELEMENT, "DFA"))
+		return new DFA(parseDFA(input));
+	else
+		throw sax::ParserException(sax::Token("EpsilonNFA / NFA / DFA", sax::Token::START_ELEMENT), input.front());
+}
+
+DFA FSMFromXMLParser::parseDFA(std::list<sax::Token>& input) {
+	DFA automaton;
+
+	popToken(input, sax::Token::START_ELEMENT, "EpsilonNFA");
+
+	parseStates(input, automaton);
+	parseInputAlphabet(input, automaton);
+	parseInitialStates(input, automaton);
+	parseFinalStates(input, automaton);
+	parseTransitions<DFA>(input, automaton);
+
+	popToken(input, sax::Token::END_ELEMENT, "EpsilonNFA");
+	return automaton;
+}
+
+NFA FSMFromXMLParser::parseNFA(std::list<sax::Token>& input) {
+	NFA automaton;
+
+	popToken(input, sax::Token::START_ELEMENT, "EpsilonNFA");
+
+	parseStates(input, automaton);
+	parseInputAlphabet(input, automaton);
+	parseInitialStates(input, automaton);
+	parseFinalStates(input, automaton);
+	parseTransitions<NFA>(input, automaton);
+
+	popToken(input, sax::Token::END_ELEMENT, "EpsilonNFA");
+	return automaton;
+}
+
+EpsilonNFA FSMFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input) {
+	EpsilonNFA automaton;
+
+	popToken(input, sax::Token::START_ELEMENT, "EpsilonNFA");
+
+	parseStates(input, automaton);
+	parseInputAlphabet(input, automaton);
+	parseInitialStates(input, automaton);
+	parseFinalStates(input, automaton);
+	parseTransitions<EpsilonNFA>(input, automaton);
+
+	popToken(input, sax::Token::END_ELEMENT, "EpsilonNFA");
+	return automaton;
+}
+
+void FSMFromXMLParser::parseStates(std::list<sax::Token> &input, FSM& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "states");
+	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
+		automaton.addState(parseState(input, "state"));
+	}
+	popToken(input, sax::Token::END_ELEMENT, "states");
+}
+
+void FSMFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input, FSM& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "inputAlphabet");
+	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
+		automaton.addInputSymbol(parseSymbol(input, "symbol"));
+	}
+	popToken(input, sax::Token::END_ELEMENT, "inputAlphabet");
+}
+
+void FSMFromXMLParser::parseInitialStates(std::list<sax::Token> &input, FSM& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "initialStates");
+	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
+		automaton.addInitialState(parseState(input, "state"));
+	}
+	popToken(input, sax::Token::END_ELEMENT, "initialStates");
+}
+
+void FSMFromXMLParser::parseFinalStates(std::list<sax::Token> &input, FSM& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "finalStates");
+	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
+		automaton.addFinalState(parseState(input, "state"));
+	}
+	popToken(input, sax::Token::END_ELEMENT, "finalStates");
+}
+
+template<class T>
+void FSMFromXMLParser::parseTransitions(std::list<sax::Token> &input, T& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "transitions");
+	while (isToken(input, sax::Token::START_ELEMENT, "transition")) {
+		parseTransition(input, automaton);
+	}
+	popToken(input, sax::Token::END_ELEMENT, "transitions");
+}
+
+State FSMFromXMLParser::parseState(std::list<sax::Token> &input, std::string tagName) {
+	popToken(input, sax::Token::START_ELEMENT, tagName);
+
+	State state(popTokenData(input, sax::Token::CHARACTER));
+	popToken(input, sax::Token::END_ELEMENT, tagName);
+	return state;
+}
+
+alphabet::Symbol FSMFromXMLParser::parseSymbol(std::list<sax::Token>& input, std::string tagName) {
+	if (isToken(input, sax::Token::START_ELEMENT, tagName)) {
+		popToken(input, sax::Token::START_ELEMENT, tagName);
+		alphabet::Symbol result = alphabet::Symbol(popTokenData(input, sax::Token::CHARACTER));
+		popToken(input, sax::Token::END_ELEMENT, tagName);
+		return result;
+	} else {
+		throw sax::ParserException(sax::Token("", sax::Token::CHARACTER), input.front());
+	}
+}
+
+std::variant<string::Epsilon, alphabet::Symbol> FSMFromXMLParser::parseInput(std::list<sax::Token>& input, std::string tagName) {
+	popToken(input, sax::Token::START_ELEMENT, tagName);
+
+	std::variant<string::Epsilon, alphabet::Symbol> result;
+	if (isTokenType(input, sax::Token::CHARACTER)) {
+		result.set<alphabet::Symbol>(alphabet::Symbol(popTokenData(input, sax::Token::CHARACTER)));
+	} else if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+		result.set<string::Epsilon>(string::Epsilon());
+		input.pop_front();
+		popToken(input, sax::Token::END_ELEMENT, "epsilon");
+	} else {
+		throw sax::ParserException(sax::Token("", sax::Token::CHARACTER), input.front());
+	}
+	
+	popToken(input, sax::Token::END_ELEMENT, tagName);
+	return result;
+}
+
+void FSMFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "transition");
+	State from = parseState(input, "from");
+	alphabet::Symbol inputSymbol = parseSymbol(input, "input");
+	State to = parseState(input, "to");
+
+	automaton.addTransition(from, inputSymbol, to);
+
+	popToken(input, sax::Token::END_ELEMENT, "transition");
+}
+
+void FSMFromXMLParser::parseTransition(std::list<sax::Token>& input, NFA& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "transition");
+	State from = parseState(input, "from");
+	alphabet::Symbol inputSymbol = parseSymbol(input, "input");
+	State to = parseState(input, "to");
+
+	automaton.addTransition(from, inputSymbol, to);
+
+	popToken(input, sax::Token::END_ELEMENT, "transition");
+}
+
+void FSMFromXMLParser::parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton) {
+	popToken(input, sax::Token::START_ELEMENT, "transition");
+	State from = parseState(input, "from");
+	std::variant<string::Epsilon, alphabet::Symbol> inputVariant = parseInput(input, "input");
+	State to = parseState(input, "to");
+
+	automaton.addTransition(from, inputVariant, to);
+
+	popToken(input, sax::Token::END_ELEMENT, "transition");
+}
+
+} /* namespace automaton */
+
diff --git a/alib2/src/automaton/FSM/FSMFromXMLParser.h b/alib2/src/automaton/FSM/FSMFromXMLParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..1fa3023247d28c69c68ee8ea5fed7b3938935a5f
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSMFromXMLParser.h
@@ -0,0 +1,62 @@
+/*
+ * FSMFromXMLParser.h
+ *
+ *  Created on: Oct 12, 2013
+ *      Author: Martin Zak
+ */
+
+#ifndef FSM_FROM_XML_PARSER_H_
+#define FSM_FROM_XML_PARSER_H_
+
+#include "../../sax/FromXMLParser.h"
+#include "FSM.h"
+#include "EpsilonNFA.h"
+#include "NFA.h"
+#include "DFA.h"
+
+#include <list>
+#include <set>
+#include "../../std/variant.hpp"
+#include "../../sax/Token.h"
+
+namespace automaton {
+
+/**
+ * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
+ */
+class FSMFromXMLParser : public sax::FromXMLParser {
+protected:
+	void parseStates(std::list<sax::Token> &input, FSM& automaton);
+	void parseInputAlphabet(std::list<sax::Token> &input, FSM& automaton);
+	void parseInitialStates(std::list<sax::Token> &input, FSM& automaton);
+	void parseFinalStates(std::list<sax::Token> &input, FSM& automaton);
+
+	template<class T>
+	void parseTransitions(std::list<sax::Token> &input, T& automaton);
+
+	void parseTransition(std::list<sax::Token>& input, EpsilonNFA& automaton);
+	void parseTransition(std::list<sax::Token>& input, NFA& automaton);
+	void parseTransition(std::list<sax::Token>& input, DFA& automaton);
+
+	State parseState(std::list<sax::Token> &input, std::string tagName);
+	std::variant<string::Epsilon, alphabet::Symbol> parseInput(std::list<sax::Token> &input, std::string tagName);
+	alphabet::Symbol parseSymbol(std::list<sax::Token> &input, std::string tagName);
+
+public:
+	/**
+	 * Parses the xml and returns the automaton. The input is destroyed in the process.
+	 * @param input XML represented as list of Tokens
+	 * @return UnknownAutomaton
+	 * @throws ParserException when an error occurs
+	 */
+	FSM* parse(std::list<sax::Token> &input);
+
+	EpsilonNFA parseEpsilonNFA(std::list<sax::Token>& input);
+	NFA parseNFA(std::list<sax::Token>& input);
+	DFA parseDFA(std::list<sax::Token>& input);
+};
+
+} /* namespace automaton */
+
+#endif /* FSM_FROM_XML_PARSER_H_ */
+
diff --git a/alib2/src/automaton/FSM/FSMToXMLComposer.cpp b/alib2/src/automaton/FSM/FSMToXMLComposer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d8d0106d09a3d840c4a5e3ce4f2d4676d16fb847
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSMToXMLComposer.cpp
@@ -0,0 +1,149 @@
+/*
+ * FSMToXMLComposer.cpp
+ *
+ *  Created on: Nov 11, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "FSMToXMLComposer.h"
+
+namespace automaton {
+
+void FSMToXMLComposer::printStates(std::list<sax::Token>& out, const FSM& automaton, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	for (auto& state : automaton.getStates()) {
+		printState(out, state, "state");
+	}
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printSymbols(std::list<sax::Token>& out, const FSM& automaton, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	for (auto& symbol : automaton.getInputAlphabet()) {
+		printSymbol(out, symbol, "symbol");
+	}
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printTransitions(std::list<sax::Token>& out, const DFA& automaton) {
+	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	for(auto& transition : automaton.getTransitions()) {
+		out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+
+		printState(out, transition.first.first, "from");
+		printInput(out, transition.first.second, "input");
+		printState(out, transition.second, "to");
+
+		out.push_back(sax::Token("transition", sax::Token::END_ELEMENT));
+	}
+
+	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printTransitions(std::list<sax::Token>& out, const NFA& automaton) {
+	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	for(auto& transition : automaton.getTransitions()) {
+		for(auto& targetState: transition.second) {
+			out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+
+			printState(out, transition.first.first, "from");
+			printInput(out, transition.first.second, "input");
+			printState(out, targetState, "to");
+
+			out.push_back(sax::Token("transition", sax::Token::END_ELEMENT));
+		}
+	}
+
+	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printTransitions(std::list<sax::Token>& out, const EpsilonNFA& automaton) {
+	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	for(auto& transition : automaton.getTransitions()) {
+		for(auto& targetState: transition.second) {
+			out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+
+			printState(out, transition.first.first, "from");
+			printInput(out, transition.first.second, "input");
+			printState(out, targetState, "to");
+
+			out.push_back(sax::Token("transition", sax::Token::END_ELEMENT));
+		}
+	}
+
+	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printState(std::list<sax::Token>& out, const State& state, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(state.getName(), sax::Token::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printInput(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(symbol.getSymbol(), sax::Token::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printInput(std::list<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	if(symbol.is<string::Epsilon>()) {
+		out.push_back(sax::Token("epsilon", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("epsilon", sax::Token::END_ELEMENT));
+	} else {
+		out.push_back(sax::Token(symbol.get<alphabet::Symbol>().getSymbol(), sax::Token::CHARACTER));
+	}
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+void FSMToXMLComposer::printSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) {
+	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(symbol.getSymbol(), sax::Token::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+}
+
+std::list<sax::Token> FSMToXMLComposer::compose(const DFA& automaton) {
+	std::list<sax::Token> out;
+	out.push_back(sax::Token("DFA", sax::Token::START_ELEMENT));
+
+	printStates(out, automaton, "states");
+	printSymbols(out, automaton, "inputAlphabet");
+	printTransitions(out, automaton);
+	printStates(out, automaton, "initialStates");
+	printStates(out, automaton, "finalStates");
+
+	out.push_back(sax::Token("DFA", sax::Token::END_ELEMENT));
+	return out;
+}
+
+std::list<sax::Token> FSMToXMLComposer::compose(const NFA& automaton) {
+	std::list<sax::Token> out;
+	out.push_back(sax::Token("NFA", sax::Token::START_ELEMENT));
+
+	printStates(out, automaton, "states");
+	printSymbols(out, automaton, "inputAlphabet");
+	printTransitions(out, automaton);
+	printStates(out, automaton, "initialStates");
+	printStates(out, automaton, "finalStates");
+
+	out.push_back(sax::Token("NFA", sax::Token::END_ELEMENT));
+	return out;
+}
+
+std::list<sax::Token> FSMToXMLComposer::compose(const EpsilonNFA& automaton) {
+	std::list<sax::Token> out;
+	out.push_back(sax::Token("EpsilonNFA", sax::Token::START_ELEMENT));
+
+	printStates(out, automaton, "states");
+	printSymbols(out, automaton, "inputAlphabet");
+	printTransitions(out, automaton);
+	printStates(out, automaton, "initialStates");
+	printStates(out, automaton, "finalStates");
+
+	out.push_back(sax::Token("EpsilonNFA", sax::Token::END_ELEMENT));
+	return out;
+}
+
+} /* namespace automaton */
+
diff --git a/alib2/src/automaton/FSM/FSMToXMLComposer.h b/alib2/src/automaton/FSM/FSMToXMLComposer.h
new file mode 100644
index 0000000000000000000000000000000000000000..18d25194a11480485be1d14ea5e2645f9f928745
--- /dev/null
+++ b/alib2/src/automaton/FSM/FSMToXMLComposer.h
@@ -0,0 +1,51 @@
+/*
+ * AutomatonToXMLComposer.h
+ *
+ *  Created on: Nov 11, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef AUTOMATON_TO_XML_COMPOSER_H_
+#define AUTOMATON_TO_XML_COMPOSER_H_
+
+#include <string>
+#include <list>
+#include "EpsilonNFA.h"
+#include "NFA.h"
+#include "DFA.h"
+#include "../../sax/Token.h"
+
+namespace automaton {
+
+/**
+ * This class contains methods to print XML representation of automata to the output stream.
+ */
+class FSMToXMLComposer {
+protected:
+	static void printStates(std::list<sax::Token>&, const FSM& automaton, std::string tagName);
+	static void printSymbols(std::list<sax::Token>&, const FSM& automaton, std::string tagName);
+	
+	static void printTransitions(std::list<sax::Token>&, const EpsilonNFA& automaton);
+	static void printTransitions(std::list<sax::Token>&, const NFA& automaton);
+	static void printTransitions(std::list<sax::Token>&, const DFA& automaton);
+
+	static void printState(std::list<sax::Token>&, const State& state, std::string tagName);
+	static void printSymbol(std::list<sax::Token>&, const alphabet::Symbol& symbol, std::string tagName);
+	static void printInput(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName);
+	static void printInput(std::list<sax::Token>&, const std::variant<string::Epsilon, alphabet::Symbol>&, std::string);
+
+public:
+	/**
+	 * Prints XML representation of UnknownAutomaton to the output stream.
+	 * @param automaton automaton to print
+	 * @return list of xml tokens representing the automaton
+	 */
+	std::list<sax::Token> compose(const DFA& automaton);
+	std::list<sax::Token> compose(const NFA& automaton);
+	std::list<sax::Token> compose(const EpsilonNFA& automaton);
+};
+
+} /* namespace automaton */
+
+#endif /* AUTOMATON_TO_XML_COMPOSER_H_ */
+
diff --git a/alib2/src/automaton/FSM/NFA.cpp b/alib2/src/automaton/FSM/NFA.cpp
index e0d75e51caadcd5ee53871386aa4d7b782185af5..5613bf085187f7ecde5a27f4782cd186f2a0c4f1 100644
--- a/alib2/src/automaton/FSM/NFA.cpp
+++ b/alib2/src/automaton/FSM/NFA.cpp
@@ -10,12 +10,6 @@
 #include <ostream>
 
 namespace automaton {
-  
-void NFA::addInputSymbol(const alphabet::Symbol& symbol) {
-	std::pair<std::set<alphabet::Symbol>::iterator, bool> ret = inputAlphabet.insert(symbol);
-	if (!ret.second)
-		throw AutomatonException("Input symbol \"" + symbol.getSymbol() + "\" already exists.");
-}
 
 void NFA::removeState(const State& state) {
 	if (initialStates.find(state) != initialStates.end()) {
diff --git a/alib2/src/automaton/FSM/NFA.h b/alib2/src/automaton/FSM/NFA.h
index ab065932c6b156a74a1113bd1ef70b37addc06e9..dbd4bf5e2a3f7d2dc2ef2b100834759d98d77c3d 100644
--- a/alib2/src/automaton/FSM/NFA.h
+++ b/alib2/src/automaton/FSM/NFA.h
@@ -9,7 +9,7 @@
 #define NFA_H_
 
 #include <map>
-#include "../Automaton.h"
+#include "FSM.h"
 #include "../State.h"
 #include "../../alphabet/Symbol.h"
 
@@ -19,15 +19,10 @@ namespace automaton {
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class NFA : public Automaton {
+class NFA : public FSM {
 protected:
 	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitions;
 public:
-	/**
-	 * @copydoc Automaton::addInputSymbol(const Symbol&)
-	 */
-	virtual void addInputSymbol(const alphabet::Symbol& symbol);
-
 	/**
 	 * @copydoc Automaton::removeState(const State&)
 	 */
diff --git a/alib2/src/factory/AutomatonConvertor.cpp b/alib2/src/factory/AutomatonConvertor.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c35a1ac1ebea28cd825130c94949dedf73dadac9
--- /dev/null
+++ b/alib2/src/factory/AutomatonConvertor.cpp
@@ -0,0 +1,192 @@
+/*
+ * AutomatonConvertor.cpp
+ *
+ *  Created on: Apr 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "AutomatonConvertor.h"
+
+#include <algorithm>
+#include <iostream>
+
+#include "../automaton/AutomatonException.h"
+
+namespace automaton {
+
+Automaton* AutomatonConvertor::buildAutomaton(const UnknownAutomaton& automaton) {
+	if (isEpsilonNFA(automaton)) {
+		return new EpsilonNFA(buildEpsilonNFA(automaton));
+	} else if (isPDA(automaton)) {
+		return new PDA(buildPDA(automaton));
+	} else if (isOneTapeDTM(automaton)) {
+		return new OneTapeDTM(buildOneTapeDTM(automaton));
+	} else {
+		throw AutomatonException("Cannot determine automaton type.");
+	}
+}
+
+void AutomatonConvertor::buildCommon(Automaton& automaton,const UnknownAutomaton& unknownAutomaton) {
+	std::set<State>::const_iterator state;
+	std::set<alphabet::Symbol>::const_iterator symbol;
+
+	const std::set<State>& states = unknownAutomaton.getStates();
+	state = states.begin();
+	while (state != states.end()) {
+		automaton.addState(*state);
+		state++;
+	}
+
+	const std::set<alphabet::Symbol>& inputAlphabet = unknownAutomaton.getInputAlphabet();
+	symbol = inputAlphabet.begin();
+	while (symbol != inputAlphabet.end()) {
+		automaton.addInputSymbol(*symbol);
+		symbol++;
+	}
+
+	const std::set<State>& initialStates = unknownAutomaton.getInitialStates();
+	state = initialStates.begin();
+	while (state != initialStates.end()) {
+		automaton.addInitialState(*state);
+		state++;
+	}
+
+	const std::set<State>& finalStates = unknownAutomaton.getFinalStates();
+	state = finalStates.begin();
+	while (state != finalStates.end()) {
+		automaton.addFinalState(*state);
+		state++;
+	}
+}
+
+bool AutomatonConvertor::isEpsilonNFA(const UnknownAutomaton& automaton) {
+	if (automaton.getStackAlphabet().size() > 0 || automaton.getInitialSymbols().size() > 0
+			|| automaton.getTapeAlphabet().size() > 0 || automaton.hasBlankSymbol()) {
+		return false;
+	}
+
+	const std::set<UnknownTransition> transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator it = transitions.begin();
+	while (it != transitions.end()) {
+		if (!isEpsilonNFATransition(*it)) {
+			return false;
+		}
+		it++;
+	}
+
+	return true;
+}
+
+bool AutomatonConvertor::isEpsilonNFATransition(const UnknownTransition& transition) {
+	return !(transition.getPop().size() > 0 || transition.getPush().size() > 0 || transition.hasOutput()
+			|| transition.getShift() != NOT_SET);
+}
+
+EpsilonNFA AutomatonConvertor::buildEpsilonNFA(const UnknownAutomaton& automaton) {
+	EpsilonNFA fsm;
+
+	buildCommon(fsm, automaton);
+
+	const std::set<UnknownTransition> transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
+	while (transition != transitions.end()) {
+		fsm.addTransition(transition->getFrom(), transition->getInput(), transition->getTo());
+		transition++;
+	}
+
+	return fsm;
+}
+
+bool AutomatonConvertor::isPDA(const UnknownAutomaton& automaton) {
+	if (automaton.getTapeAlphabet().size() > 0 || automaton.hasBlankSymbol()) {
+		return false;
+	}
+
+	const std::set<UnknownTransition> transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
+	while (transition != transitions.end()) {
+		if (!isPDATransition(*transition)) {
+			return false;
+		}
+		transition++;
+	}
+
+	return true;
+}
+
+bool AutomatonConvertor::isPDATransition(const UnknownTransition& transition) {
+	return !(transition.hasOutput() || transition.getShift() != NOT_SET);
+}
+
+PDA AutomatonConvertor::buildPDA(const UnknownAutomaton& automaton) {
+	PDA pda;
+	buildCommon(pda, automaton);
+
+	const std::set<alphabet::Symbol>& stackAlphabet = automaton.getStackAlphabet();
+	std::set<alphabet::Symbol>::iterator stackSymbol = stackAlphabet.begin();
+	while (stackSymbol != stackAlphabet.end()) {
+		pda.addStackSymbol(*stackSymbol);
+		stackSymbol++;
+	}
+
+	pda.setInitialSymbols(automaton.getInitialSymbols());
+
+	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
+	while (transition != transitions.end()) {
+		pda.addTransition(transition->getFrom(), transition->getInput().get<alphabet::Symbol>(), transition->getPop(), transition->getTo(), transition->getPush());
+		transition++;
+	}
+
+	return pda;
+}
+
+bool AutomatonConvertor::isOneTapeDTM(const UnknownAutomaton& automaton) {
+	if (automaton.getStackAlphabet().size() > 0 || automaton.getInitialSymbols().size() > 0) {
+		return false;
+	}
+
+	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
+	while (transition != transitions.end()) {
+		if (!isOneTapeDTMTransition(*transition)) {
+			return false;
+		}
+		transition++;
+	}
+
+	return true;
+
+}
+
+bool AutomatonConvertor::isOneTapeDTMTransition(const UnknownTransition& transition) {
+	return !(transition.getPop().size() > 0 || transition.getPush().size() > 0);
+
+}
+
+OneTapeDTM AutomatonConvertor::buildOneTapeDTM(const UnknownAutomaton& automaton) {
+	OneTapeDTM tm;
+
+	const std::set<alphabet::Symbol>& tapeAlphabet = automaton.getTapeAlphabet();
+	std::set<alphabet::Symbol>::const_iterator tapeSymbol = tapeAlphabet.begin();
+	while (tapeSymbol != tapeAlphabet.end()) {
+		tm.addTapeSymbol(*tapeSymbol);
+		tapeSymbol++;
+	}
+
+	buildCommon(tm, automaton);
+
+	tm.setBlankSymbol(automaton.getBlankSymbol());
+
+	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
+	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
+	while (transition != transitions.end()) {
+		tm.addTransition(transition->getFrom(), transition->getInput().get<alphabet::Symbol>(), transition->getTo(), transition->getOutput().get<alphabet::Symbol>(), transition->getShift());
+		transition++;
+	}
+
+	return tm;
+
+}
+
+} /* namespace automaton */
diff --git a/alib2/src/factory/AutomatonConvertor.h b/alib2/src/factory/AutomatonConvertor.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d82f77a64aec6d3aee6635e4daad0f55328b91e
--- /dev/null
+++ b/alib2/src/factory/AutomatonConvertor.h
@@ -0,0 +1,114 @@
+/*
+ * AutomatonFactory.h
+ *
+ *  Created on: Apr 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef AUTOMATON_CONVERTOR_H_
+#define AUTOMATON_FONVERTOR_H_
+
+#include "../automaton/UnknownAutomaton.h"
+#include "../automaton/FSM/EpsilonNFA.h"
+#include "../automaton/PDA/PDA.h"
+#include "../automaton/TM/OneTapeDTM.h"
+
+namespace automaton {
+
+/**
+ * Builds specific automatons from UnknownAutomaton. It converts an UnknownAutomaton to the most general automaton in the group - EpsilonNFA for FSA, ...
+ */
+class AutomatonConvertor {
+public:
+	/**
+	 * Tries to create specific automaton from UnknownAutomaton.
+	 * @param automaton source UnknownAutomaton
+	 * @return pointer to new automaton
+	 * @throws AutomatonException when specific automaton cannot
+	 * be created form UnknownAutomaton (e.g. automaton type is not recognized)
+	 */
+	static Automaton* buildAutomaton(const UnknownAutomaton& automaton);
+
+	/**
+	 * Checks that FSM can be build from UnknownAutomaton. That means UnknownAutomaton
+	 * doesn't contain elements that are not present in the FSM.
+	 * @param automaton source UnknownAutomaton
+	 * @return true when FSM can be build from UnknownAutomaton, false otherwise
+	 */
+	static bool isEpsilonNFA(const UnknownAutomaton& automaton);
+
+	/**
+	 * Tries to build FSM from the UnknownAutomaton. Ignores elements that
+	 * are not required for the FSM.
+	 * @param automaton source UnknownAutomaton
+	 * @return EpsilonNFA
+	 */
+	static EpsilonNFA buildEpsilonNFA(const UnknownAutomaton& automaton);
+
+	/**
+	 * Checks that PDA can be build from UnknownAutomaton. That means UnknownAutomaton
+	 * doesn't contain elements that are not present in the PDA.
+	 * @param automaton source UnknownAutomaton
+	 * @return true when PDA can be build from UnknownAutomaton, false otherwise
+	 */
+	static bool isPDA(const UnknownAutomaton& automaton);
+
+	/**
+	 * Tries to build PDA from the UnknownAutomaton. Ignores elements that
+	 * are not required for the PDA.
+	 * @param automaton source UnknownAutomaton
+	 * @return PDA
+	 */
+	static PDA buildPDA(const UnknownAutomaton& automaton);
+
+	/**
+	 * Checks that TM can be build from UnknownAutomaton. That means UnknownAutomaton
+	 * doesn't contain elements that are not present in the TM.
+	 * @param automaton source UnknownAutomaton
+	 * @return true when TM can be build from UnknownAutomaton, false otherwise
+	 */
+	static bool isOneTapeDTM(const UnknownAutomaton& automaton);
+
+	/**
+	 * Tries to build TM from the UnknownAutomaton. Ignores elements that
+	 * are not required for the TM.
+	 * @param automaton source UnknownAutomaton
+	 * @return TM
+	 */
+	static OneTapeDTM buildOneTapeDTM(const UnknownAutomaton& automaton);
+
+protected:
+	/**
+	 * Build common part (states, input alphabet, initial states, final states)
+	 * of the automaton from UnknownAutomaton.
+	 * @param automaton automaton to build (destination)
+	 * @param unknownAutomaton source automaton
+	 */
+	static void buildCommon(Automaton& automaton, const UnknownAutomaton& unknownAutomaton);
+
+	/**
+	 * Checks that transition contains only elements that are valid for FSM.
+	 * @param transition UnknownTransition to check
+	 * @return true when transition is FSM transition
+	 */
+	static bool isEpsilonNFATransition(const UnknownTransition& transition);
+
+	/**
+	 * Checks that transition contains only elements that are valid for PDA.
+	 * @param transition UnknownTransition to check
+	 * @return true when transition is PDA transition
+	 */
+	static bool isPDATransition(const UnknownTransition& transition);
+
+	/**
+	 * Checks that transition contains only elements that are valid for TM.
+	 * @param transition UnknownTransition to check
+	 * @return true when transition is TM transition
+	 */
+	static bool isOneTapeDTMTransition(const UnknownTransition& transition);
+};
+
+} /* namespace automaton */
+
+#endif /* AUTOMATON_CONVERTOR_H_ */
+
diff --git a/alib2/src/factory/AutomatonFactory.cpp b/alib2/src/factory/AutomatonFactory.cpp
index 1368529b005f35edf578b26d5a796ed0acfb58ce..2f18bba2384b7d731ad8b9ec52ca72ba129826b4 100644
--- a/alib2/src/factory/AutomatonFactory.cpp
+++ b/alib2/src/factory/AutomatonFactory.cpp
@@ -2,19 +2,15 @@
  * AutomatonFactory.cpp
  *
  *  Created on: Apr 23, 2013
- *      Author: martin
+ *      Author: Martin Zak
  */
 
 #include "AutomatonFactory.h"
 
-#include <algorithm>
-#include <iostream>
-
 #include "../sax/SaxParseInterface.h"
 #include "../sax/SaxComposeInterface.h"
 #include "../automaton/AutomatonFromXMLParser.h"
 #include "../automaton/AutomatonToXMLComposer.h"
-#include "../automaton/AutomatonException.h"
 
 namespace automaton {
 
@@ -70,179 +66,4 @@ std::list<sax::Token> AutomatonFactory::compose(const UnknownAutomaton& automato
 	return composer.compose(automaton);
 }
 
-Automaton* AutomatonFactory::buildAutomaton(const UnknownAutomaton& automaton) {
-	if (isEpsilonNFA(automaton)) {
-		return new EpsilonNFA(buildEpsilonNFA(automaton));
-	} else if (isPDA(automaton)) {
-		return new PDA(buildPDA(automaton));
-	} else if (isOneTapeDTM(automaton)) {
-		return new OneTapeDTM(buildOneTapeDTM(automaton));
-	} else {
-		throw AutomatonException("Cannot determine automaton type.");
-	}
-}
-
-void AutomatonFactory::buildCommon(Automaton& automaton,const UnknownAutomaton& unknownAutomaton) {
-	std::set<State>::const_iterator state;
-	std::set<alphabet::Symbol>::const_iterator symbol;
-
-	const std::set<State>& states = unknownAutomaton.getStates();
-	state = states.begin();
-	while (state != states.end()) {
-		automaton.addState(*state);
-		state++;
-	}
-
-	const std::set<alphabet::Symbol>& inputAlphabet = unknownAutomaton.getInputAlphabet();
-	symbol = inputAlphabet.begin();
-	while (symbol != inputAlphabet.end()) {
-		automaton.addInputSymbol(*symbol);
-		symbol++;
-	}
-
-	const std::set<State>& initialStates = unknownAutomaton.getInitialStates();
-	state = initialStates.begin();
-	while (state != initialStates.end()) {
-		automaton.addInitialState(*state);
-		state++;
-	}
-
-	const std::set<State>& finalStates = unknownAutomaton.getFinalStates();
-	state = finalStates.begin();
-	while (state != finalStates.end()) {
-		automaton.addFinalState(*state);
-		state++;
-	}
-}
-
-bool AutomatonFactory::isEpsilonNFA(const UnknownAutomaton& automaton) {
-	if (automaton.getStackAlphabet().size() > 0 || automaton.getInitialSymbols().size() > 0
-			|| automaton.getTapeAlphabet().size() > 0 || automaton.hasBlankSymbol()) {
-		return false;
-	}
-
-	const std::set<UnknownTransition> transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator it = transitions.begin();
-	while (it != transitions.end()) {
-		if (!isEpsilonNFATransition(*it)) {
-			return false;
-		}
-		it++;
-	}
-
-	return true;
-}
-
-bool AutomatonFactory::isEpsilonNFATransition(const UnknownTransition& transition) {
-	return !(transition.getPop().size() > 0 || transition.getPush().size() > 0 || transition.hasOutput()
-			|| transition.getShift() != NOT_SET);
-}
-
-EpsilonNFA AutomatonFactory::buildEpsilonNFA(const UnknownAutomaton& automaton) {
-	EpsilonNFA fsm;
-
-	buildCommon(fsm, automaton);
-
-	const std::set<UnknownTransition> transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
-	while (transition != transitions.end()) {
-		fsm.addTransition(transition->getFrom(), transition->getInput(), transition->getTo());
-		transition++;
-	}
-
-	return fsm;
-}
-
-bool AutomatonFactory::isPDA(const UnknownAutomaton& automaton) {
-	if (automaton.getTapeAlphabet().size() > 0 || automaton.hasBlankSymbol()) {
-		return false;
-	}
-
-	const std::set<UnknownTransition> transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
-	while (transition != transitions.end()) {
-		if (!isPDATransition(*transition)) {
-			return false;
-		}
-		transition++;
-	}
-
-	return true;
-}
-
-bool AutomatonFactory::isPDATransition(const UnknownTransition& transition) {
-	return !(transition.hasOutput() || transition.getShift() != NOT_SET);
-}
-
-PDA AutomatonFactory::buildPDA(const UnknownAutomaton& automaton) {
-	PDA pda;
-	buildCommon(pda, automaton);
-
-	const std::set<alphabet::Symbol>& stackAlphabet = automaton.getStackAlphabet();
-	std::set<alphabet::Symbol>::iterator stackSymbol = stackAlphabet.begin();
-	while (stackSymbol != stackAlphabet.end()) {
-		pda.addStackSymbol(*stackSymbol);
-		stackSymbol++;
-	}
-
-	pda.setInitialSymbols(automaton.getInitialSymbols());
-
-	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
-	while (transition != transitions.end()) {
-		pda.addTransition(transition->getFrom(), transition->getInput().get<alphabet::Symbol>(), transition->getPop(), transition->getTo(), transition->getPush());
-		transition++;
-	}
-
-	return pda;
-}
-
-bool AutomatonFactory::isOneTapeDTM(const UnknownAutomaton& automaton) {
-	if (automaton.getStackAlphabet().size() > 0 || automaton.getInitialSymbols().size() > 0) {
-		return false;
-	}
-
-	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
-	while (transition != transitions.end()) {
-		if (!isOneTapeDTMTransition(*transition)) {
-			return false;
-		}
-		transition++;
-	}
-
-	return true;
-
-}
-
-bool AutomatonFactory::isOneTapeDTMTransition(const UnknownTransition& transition) {
-	return !(transition.getPop().size() > 0 || transition.getPush().size() > 0);
-
-}
-
-OneTapeDTM AutomatonFactory::buildOneTapeDTM(const UnknownAutomaton& automaton) {
-	OneTapeDTM tm;
-
-	const std::set<alphabet::Symbol>& tapeAlphabet = automaton.getTapeAlphabet();
-	std::set<alphabet::Symbol>::const_iterator tapeSymbol = tapeAlphabet.begin();
-	while (tapeSymbol != tapeAlphabet.end()) {
-		tm.addTapeSymbol(*tapeSymbol);
-		tapeSymbol++;
-	}
-
-	buildCommon(tm, automaton);
-
-	tm.setBlankSymbol(automaton.getBlankSymbol());
-
-	const std::set<UnknownTransition>& transitions = automaton.getTransitions();
-	std::set<UnknownTransition>::const_iterator transition = transitions.begin();
-	while (transition != transitions.end()) {
-		tm.addTransition(transition->getFrom(), transition->getInput().get<alphabet::Symbol>(), transition->getTo(), transition->getOutput().get<alphabet::Symbol>(), transition->getShift());
-		transition++;
-	}
-
-	return tm;
-
-}
-
 } /* namespace automaton */
diff --git a/alib2/src/factory/AutomatonFactory.h b/alib2/src/factory/AutomatonFactory.h
index a87751a79443f22d2de7a2e72d5e72d755f46d8a..bf6ce37bb9ffb1a79ed8dacffcb8e6b23610ed42 100644
--- a/alib2/src/factory/AutomatonFactory.h
+++ b/alib2/src/factory/AutomatonFactory.h
@@ -2,18 +2,15 @@
  * AutomatonFactory.h
  *
  *  Created on: Apr 23, 2013
- *      Author: martin
+ *      Author: Martin Zak
  */
 
-#ifndef AUTOMATONFACTORY_H_
-#define AUTOMATONFACTORY_H_
+#ifndef AUTOMATON_FACTORY_H_
+#define AUTOMATON_FACTORY_H_
 
 #include <string>
 #include "../sax/Token.h"
 #include "../automaton/UnknownAutomaton.h"
-#include "../automaton/FSM/EpsilonNFA.h"
-#include "../automaton/PDA/PDA.h"
-#include "../automaton/TM/OneTapeDTM.h"
 
 namespace automaton {
 
@@ -74,63 +71,6 @@ public:
 	 */
 	static void toStream(const UnknownAutomaton&, std::ostream& out);
 	
-	/**
-	 * Tries to create specific automaton from UnknownAutomaton.
-	 * @param automaton source UnknownAutomaton
-	 * @return pointer to new automaton
-	 * @throws AutomatonException when specific automaton cannot
-	 * be created form UnknownAutomaton (e.g. automaton type is not recognized)
-	 */
-	static Automaton* buildAutomaton(const UnknownAutomaton& automaton);
-
-	/**
-	 * Checks that FSM can be build from UnknownAutomaton. That means UnknownAutomaton
-	 * doesn't contain elements that are not present in the FSM.
-	 * @param automaton source UnknownAutomaton
-	 * @return true when FSM can be build from UnknownAutomaton, false otherwise
-	 */
-	static bool isEpsilonNFA(const UnknownAutomaton& automaton);
-
-	/**
-	 * Tries to build FSM from the UnknownAutomaton. Ignores elements that
-	 * are not required for the FSM.
-	 * @param automaton source UnknownAutomaton
-	 * @return EpsilonNFA
-	 */
-	static EpsilonNFA buildEpsilonNFA(const UnknownAutomaton& automaton);
-
-	/**
-	 * Checks that PDA can be build from UnknownAutomaton. That means UnknownAutomaton
-	 * doesn't contain elements that are not present in the PDA.
-	 * @param automaton source UnknownAutomaton
-	 * @return true when PDA can be build from UnknownAutomaton, false otherwise
-	 */
-	static bool isPDA(const UnknownAutomaton& automaton);
-
-	/**
-	 * Tries to build PDA from the UnknownAutomaton. Ignores elements that
-	 * are not required for the PDA.
-	 * @param automaton source UnknownAutomaton
-	 * @return PDA
-	 */
-	static PDA buildPDA(const UnknownAutomaton& automaton);
-
-	/**
-	 * Checks that TM can be build from UnknownAutomaton. That means UnknownAutomaton
-	 * doesn't contain elements that are not present in the TM.
-	 * @param automaton source UnknownAutomaton
-	 * @return true when TM can be build from UnknownAutomaton, false otherwise
-	 */
-	static bool isOneTapeDTM(const UnknownAutomaton& automaton);
-
-	/**
-	 * Tries to build TM from the UnknownAutomaton. Ignores elements that
-	 * are not required for the TM.
-	 * @param automaton source UnknownAutomaton
-	 * @return TM
-	 */
-	static OneTapeDTM buildOneTapeDTM(const UnknownAutomaton& automaton);
-
 protected:
 
 	/**
@@ -146,38 +86,9 @@ protected:
 	 * @return parsed RegExp
 	 */
 	static std::list<sax::Token> compose(const UnknownAutomaton&);
-
-	/**
-	 * Build common part (states, input alphabet, initial states, final states)
-	 * of the automaton from UnknownAutomaton.
-	 * @param automaton automaton to build (destination)
-	 * @param unknownAutomaton source automaton
-	 */
-	static void buildCommon(Automaton& automaton, const UnknownAutomaton& unknownAutomaton);
-
-	/**
-	 * Checks that transition contains only elements that are valid for FSM.
-	 * @param transition UnknownTransition to check
-	 * @return true when transition is FSM transition
-	 */
-	static bool isEpsilonNFATransition(const UnknownTransition& transition);
-
-	/**
-	 * Checks that transition contains only elements that are valid for PDA.
-	 * @param transition UnknownTransition to check
-	 * @return true when transition is PDA transition
-	 */
-	static bool isPDATransition(const UnknownTransition& transition);
-
-	/**
-	 * Checks that transition contains only elements that are valid for TM.
-	 * @param transition UnknownTransition to check
-	 * @return true when transition is TM transition
-	 */
-	static bool isOneTapeDTMTransition(const UnknownTransition& transition);
 };
 
 } /* namespace automaton */
 
-#endif /* AUTOMATONFACTORY_H_ */
+#endif /* AUTOMATON_FACTORY_H_ */