From e428c4cc816f34c38d8cab77eb503513b3427ec7 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Thu, 22 Jan 2015 14:36:25 +0100
Subject: [PATCH] Move AutomatonFromStringParser/Composer

---
 alib2data/src/StringApi.cpp                   |   4 +-
 alib2data/src/StringApi.hpp                   |   8 +-
 ...Lexer.cpp => AutomatonFromStringLexer.cpp} |  12 +-
 ...ringLexer.h => AutomatonFromStringLexer.h} |  10 +-
 ...rser.cpp => AutomatonFromStringParser.cpp} | 238 +++++++++---------
 ...ngParser.h => AutomatonFromStringParser.h} |  24 +-
 ...oser.cpp => AutomatonToStringComposer.cpp} |  60 ++---
 ...Composer.h => AutomatonToStringComposer.h} |  20 +-
 8 files changed, 188 insertions(+), 188 deletions(-)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonFromStringLexer.cpp => AutomatonFromStringLexer.cpp} (85%)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonFromStringLexer.h => AutomatonFromStringLexer.h} (69%)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonFromStringParser.cpp => AutomatonFromStringParser.cpp} (50%)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonFromStringParser.h => AutomatonFromStringParser.h} (77%)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonToStringComposer.cpp => AutomatonToStringComposer.cpp} (69%)
 rename alib2data/src/automaton/{FSM/FiniteAutomatonToStringComposer.h => AutomatonToStringComposer.h} (85%)

diff --git a/alib2data/src/StringApi.cpp b/alib2data/src/StringApi.cpp
index cadca5b6ab..b1ed53c2f6 100644
--- a/alib2data/src/StringApi.cpp
+++ b/alib2data/src/StringApi.cpp
@@ -15,7 +15,7 @@ const label::LabelFromStringParser FromStringParsers::labelParser;
 const alphabet::SymbolFromStringParser FromStringParsers::symbolParser;
 const regexp::RegExpFromStringParser FromStringParsers::regexpParser;
 const string::StringFromStringParser FromStringParsers::stringParser;
-const automaton::FiniteAutomatonFromStringParser FromStringParsers::automatonParser;
+const automaton::AutomatonFromStringParser FromStringParsers::automatonParser;
 const grammar::GrammarFromStringParser FromStringParsers::grammarParser;
 const primitive::PrimitiveFromStringParser FromStringParsers::primitiveParser;
 
@@ -23,7 +23,7 @@ const label::LabelToStringComposer ToStringComposers::labelComposer;
 const alphabet::SymbolToStringComposer ToStringComposers::symbolComposer;
 const regexp::RegExpToStringComposer ToStringComposers::regexpComposer;
 const string::StringToStringComposer ToStringComposers::stringComposer;
-const automaton::FiniteAutomatonToStringComposer ToStringComposers::automatonComposer;
+const automaton::AutomatonToStringComposer ToStringComposers::automatonComposer;
 const grammar::GrammarToStringComposer ToStringComposers::grammarComposer;
 const primitive::PrimitiveToStringComposer ToStringComposers::primitiveComposer;
 
diff --git a/alib2data/src/StringApi.hpp b/alib2data/src/StringApi.hpp
index 5b5009ccee..cc9044f776 100644
--- a/alib2data/src/StringApi.hpp
+++ b/alib2data/src/StringApi.hpp
@@ -12,7 +12,7 @@
 #include "alphabet/SymbolFromStringParser.h"
 #include "regexp/RegExpFromStringParser.h"
 #include "string/StringFromStringParser.h"
-#include "automaton/FSM/FiniteAutomatonFromStringParser.h"
+#include "automaton/AutomatonFromStringParser.h"
 #include "grammar/GrammarFromStringParser.h"
 #include "primitive/PrimitiveFromStringParser.h"
 
@@ -20,7 +20,7 @@
 #include "alphabet/SymbolToStringComposer.h"
 #include "regexp/RegExpToStringComposer.h"
 #include "string/StringToStringComposer.h"
-#include "automaton/FSM/FiniteAutomatonToStringComposer.h"
+#include "automaton/AutomatonToStringComposer.h"
 #include "grammar/GrammarToStringComposer.h"
 #include "primitive/PrimitiveToStringComposer.h"
 
@@ -83,7 +83,7 @@ public:
 	static const alphabet::SymbolFromStringParser symbolParser;
 	static const regexp::RegExpFromStringParser regexpParser;
 	static const string::StringFromStringParser stringParser;
-	static const automaton::FiniteAutomatonFromStringParser automatonParser;
+	static const automaton::AutomatonFromStringParser automatonParser;
 	static const grammar::GrammarFromStringParser grammarParser;
 	static const primitive::PrimitiveFromStringParser primitiveParser;
 
@@ -95,7 +95,7 @@ public:
 	static const alphabet::SymbolToStringComposer symbolComposer;
 	static const regexp::RegExpToStringComposer regexpComposer;
 	static const string::StringToStringComposer stringComposer;
-	static const automaton::FiniteAutomatonToStringComposer automatonComposer;
+	static const automaton::AutomatonToStringComposer automatonComposer;
 	static const grammar::GrammarToStringComposer grammarComposer;
 	static const primitive::PrimitiveToStringComposer primitiveComposer;
 };
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.cpp b/alib2data/src/automaton/AutomatonFromStringLexer.cpp
similarity index 85%
rename from alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.cpp
rename to alib2data/src/automaton/AutomatonFromStringLexer.cpp
index b0d149c410..d0bae416bc 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.cpp
+++ b/alib2data/src/automaton/AutomatonFromStringLexer.cpp
@@ -1,17 +1,17 @@
 /*
- * FiniteAutomatonFromStringLexer.cpp
+ * AutomatonFromStringLexer.cpp
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#include "FiniteAutomatonFromStringLexer.h"
-#include "../../std/istream.h"
+#include "AutomatonFromStringLexer.h"
+#include "../std/istream.h"
 
 namespace automaton {
 
-FiniteAutomatonFromStringLexer::Token FiniteAutomatonFromStringLexer::next(std::istream& in) const {
-	FiniteAutomatonFromStringLexer::Token token;
+AutomatonFromStringLexer::Token AutomatonFromStringLexer::next(std::istream& in) const {
+	AutomatonFromStringLexer::Token token;
 	token.type = TokenType::ERROR;
 	token.value = "";
 	token.raw = "";
@@ -98,7 +98,7 @@ L1:
 	}
 }
 
-void FiniteAutomatonFromStringLexer::putback(std::istream& in, FiniteAutomatonFromStringLexer::Token token) const {
+void AutomatonFromStringLexer::putback(std::istream& in, AutomatonFromStringLexer::Token token) const {
 	while(!token.raw.empty()) {
 		in.putback(token.raw.back());
 		token.raw.pop_back();
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.h b/alib2data/src/automaton/AutomatonFromStringLexer.h
similarity index 69%
rename from alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.h
rename to alib2data/src/automaton/AutomatonFromStringLexer.h
index e171295f88..32f14d4bb2 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringLexer.h
+++ b/alib2data/src/automaton/AutomatonFromStringLexer.h
@@ -1,19 +1,19 @@
 /*
- * FiniteAutomatonFromStringLexer.h
+ * AutomatonFromStringLexer.h
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#ifndef FINITE_AUTOMATON_FROM_STRING_LEXER_H_
-#define FINITE_AUTOMATON_FROM_STRING_LEXER_H_
+#ifndef AUTOMATON_FROM_STRING_LEXER_H_
+#define AUTOMATON_FROM_STRING_LEXER_H_
 
 #include <string>
 #include <sstream>
 
 namespace automaton {
 
-class FiniteAutomatonFromStringLexer {
+class AutomatonFromStringLexer {
 public:
 	enum class TokenType {
 		EPSILON_NFA,
@@ -42,4 +42,4 @@ public:
 
 } /* namepsace automaton */
 
-#endif /* FINITE_AUTOMATON_FROM_STRING_LEXER_H_ */
+#endif /* AUTOMATON_FROM_STRING_LEXER_H_ */
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.cpp b/alib2data/src/automaton/AutomatonFromStringParser.cpp
similarity index 50%
rename from alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.cpp
rename to alib2data/src/automaton/AutomatonFromStringParser.cpp
index f24fe5957e..96d2ae27f1 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.cpp
+++ b/alib2data/src/automaton/AutomatonFromStringParser.cpp
@@ -1,70 +1,70 @@
 /*
- * FiniteAutomatonFromStringParser.cpp
+ * AutomatonFromStringParser.cpp
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#include "FiniteAutomatonFromStringParser.h"
+#include "AutomatonFromStringParser.h"
 
-#include "../../exception/AlibException.h"
+#include "../exception/AlibException.h"
 
-#include "EpsilonNFA.h"
-#include "MultiInitialStateNFA.h"
-#include "NFA.h"
-#include "DFA.h"
+#include "FSM/EpsilonNFA.h"
+#include "FSM/MultiInitialStateNFA.h"
+#include "FSM/NFA.h"
+#include "FSM/DFA.h"
 
-#include "../../StringApi.hpp"
+#include "../StringApi.hpp"
 
 namespace automaton {
 
-Automaton FiniteAutomatonFromStringParser::parseAutomaton(std::istream& input) const {
+Automaton AutomatonFromStringParser::parseAutomaton(std::istream& input) const {
 	return parseAutomaton(input, std::set<FEATURES>({FEATURES::EPSILON_NFA, FEATURES::MULTI_INITIAL_STATE_NFA, FEATURES::NFA, FEATURES::DFA}));
 }
 
-Automaton FiniteAutomatonFromStringParser::parseAutomaton(std::istream& input, const std::set<FEATURES>& features) const {
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type == FiniteAutomatonFromStringLexer::TokenType::EPSILON_NFA) {
+Automaton AutomatonFromStringParser::parseAutomaton(std::istream& input, const std::set<FEATURES>& features) const {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type == AutomatonFromStringLexer::TokenType::EPSILON_NFA) {
 		if(!features.count(FEATURES::EPSILON_NFA)) throw exception::AlibException("Disabled formalism EpsilonNFA");
-		m_FiniteAutomatonLexer.putback(input, token);
+		m_AutomatonLexer.putback(input, token);
 		return Automaton(parseEpsilonNFA(input));
-	} else if(token.type == FiniteAutomatonFromStringLexer::TokenType::MULTI_INITIAL_STATE_NFA) {
+	} else if(token.type == AutomatonFromStringLexer::TokenType::MULTI_INITIAL_STATE_NFA) {
 		if(!features.count(FEATURES::MULTI_INITIAL_STATE_NFA)) throw exception::AlibException("Disabled Formalism MultiInitialStateNFA");
-		m_FiniteAutomatonLexer.putback(input, token);
+		m_AutomatonLexer.putback(input, token);
 		return Automaton(parseMultiInitialStateNFA(input));
-	} else if(token.type == FiniteAutomatonFromStringLexer::TokenType::NFA) {
+	} else if(token.type == AutomatonFromStringLexer::TokenType::NFA) {
 		if(!features.count(FEATURES::NFA)) throw exception::AlibException("Disabled formalism NFA");
-		m_FiniteAutomatonLexer.putback(input, token);
+		m_AutomatonLexer.putback(input, token);
 		return Automaton(parseNFA(input));
-	} else if(token.type == FiniteAutomatonFromStringLexer::TokenType::DFA) {
+	} else if(token.type == AutomatonFromStringLexer::TokenType::DFA) {
 		if(!features.count(FEATURES::DFA)) throw exception::AlibException("Disabled formalism DFA");
-		m_FiniteAutomatonLexer.putback(input, token);
+		m_AutomatonLexer.putback(input, token);
 		return Automaton(parseDFA(input));
 	} else {
 		throw exception::AlibException("Formalism not recognised (token = \"" + token.value + "\")");
 	}
 }
 
-EpsilonNFA FiniteAutomatonFromStringParser::parseEpsilonNFA(std::istream& input) const {
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type != FiniteAutomatonFromStringLexer::TokenType::EPSILON_NFA) {
+EpsilonNFA AutomatonFromStringParser::parseEpsilonNFA(std::istream& input) const {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type != AutomatonFromStringLexer::TokenType::EPSILON_NFA) {
 		throw exception::AlibException("Unrecognised ENFA token.");
 	}
 	std::vector<std::variant<string::Epsilon, alphabet::Symbol> > symbols;
 
-	token = m_FiniteAutomatonLexer.next(input);
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::ERROR) {
-			m_FiniteAutomatonLexer.putback(input, token);
+	token = m_AutomatonLexer.next(input);
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		if(token.type == AutomatonFromStringLexer::TokenType::ERROR) {
+			m_AutomatonLexer.putback(input, token);
 			alphabet::Symbol symbol = alib::stringApi<alphabet::Symbol>::parse(input);
 
 			std::variant<string::Epsilon, alphabet::Symbol> symbolVariant(symbol);
 			symbols.push_back(symbolVariant);
-		} else if(token.type == FiniteAutomatonFromStringLexer::TokenType::EPSILON) {
+		} else if(token.type == AutomatonFromStringLexer::TokenType::EPSILON) {
 			symbols.push_back(std::variant<string::Epsilon, alphabet::Symbol>(string::Epsilon::EPSILON));
 		}
 
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	State* initialState = NULL;
@@ -73,17 +73,17 @@ EpsilonNFA FiniteAutomatonFromStringParser::parseEpsilonNFA(std::istream& input)
 	std::set<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, State>> transitionFunction;
 
 	parseEpsilonNFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-	token = m_FiniteAutomatonLexer.next(input);
+	token = m_AutomatonLexer.next(input);
 
-	while(token.type == FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		token = m_FiniteAutomatonLexer.next(input);
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::TEOF)
+	while(token.type == AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		token = m_AutomatonLexer.next(input);
+		if(token.type == AutomatonFromStringLexer::TokenType::TEOF)
 			break;
 		else
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 
 		parseEpsilonNFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	if(initialState == NULL) throw exception::AlibException("No initial state recognised.");
@@ -104,56 +104,56 @@ EpsilonNFA FiniteAutomatonFromStringParser::parseEpsilonNFA(std::istream& input)
 	return  res;
 }
 
-MultiInitialStateNFA FiniteAutomatonFromStringParser::parseMultiInitialStateNFA(std::istream& input) const {
+MultiInitialStateNFA AutomatonFromStringParser::parseMultiInitialStateNFA(std::istream& input) const {
 	MultiInitialStateNFA res;
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type != FiniteAutomatonFromStringLexer::TokenType::MULTI_INITIAL_STATE_NFA) {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type != AutomatonFromStringLexer::TokenType::MULTI_INITIAL_STATE_NFA) {
 		throw exception::AlibException("Unrecognised MISNFA token.");
 	}
 	std::vector<alphabet::Symbol> symbols;
 
-	token = m_FiniteAutomatonLexer.next(input);
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		m_FiniteAutomatonLexer.putback(input, token);
+	token = m_AutomatonLexer.next(input);
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		m_AutomatonLexer.putback(input, token);
 		alphabet::Symbol symbol = alib::stringApi<alphabet::Symbol>::parse(input);
 		res.addInputSymbol(symbol);
 		symbols.push_back(symbol);
 
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	parseMultiInitialStateNFATransition(input, res, symbols);
-	token = m_FiniteAutomatonLexer.next(input);
+	token = m_AutomatonLexer.next(input);
 
-	while(token.type == FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		token = m_FiniteAutomatonLexer.next(input);
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::TEOF)
+	while(token.type == AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		token = m_AutomatonLexer.next(input);
+		if(token.type == AutomatonFromStringLexer::TokenType::TEOF)
 			break;
 		else
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 
 		parseMultiInitialStateNFATransition(input, res, symbols);
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	return  res;
 }
 
-NFA FiniteAutomatonFromStringParser::parseNFA(std::istream& input) const {
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type != FiniteAutomatonFromStringLexer::TokenType::NFA) {
+NFA AutomatonFromStringParser::parseNFA(std::istream& input) const {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type != AutomatonFromStringLexer::TokenType::NFA) {
 		throw exception::AlibException("Unrecognised NFA token.");
 	}
 	std::vector<alphabet::Symbol> symbols;
 
-	token = m_FiniteAutomatonLexer.next(input);
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		m_FiniteAutomatonLexer.putback(input, token);
+	token = m_AutomatonLexer.next(input);
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		m_AutomatonLexer.putback(input, token);
 		alphabet::Symbol symbol = alib::stringApi<alphabet::Symbol>::parse(input);
 		symbols.push_back(symbol);
 
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	State* initialState = NULL;
@@ -162,17 +162,17 @@ NFA FiniteAutomatonFromStringParser::parseNFA(std::istream& input) const {
 	std::set<std::tuple<State, alphabet::Symbol, State>> transitionFunction;
 
 	parseNFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-	token = m_FiniteAutomatonLexer.next(input);
+	token = m_AutomatonLexer.next(input);
 
-	while(token.type == FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		token = m_FiniteAutomatonLexer.next(input);
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::TEOF)
+	while(token.type == AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		token = m_AutomatonLexer.next(input);
+		if(token.type == AutomatonFromStringLexer::TokenType::TEOF)
 			break;
 		else
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 
 		parseNFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	if(initialState == NULL) throw exception::AlibException("No initial state recognised.");
@@ -190,20 +190,20 @@ NFA FiniteAutomatonFromStringParser::parseNFA(std::istream& input) const {
 	return  res;
 }
 
-DFA FiniteAutomatonFromStringParser::parseDFA(std::istream& input) const {
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type != FiniteAutomatonFromStringLexer::TokenType::DFA) {
+DFA AutomatonFromStringParser::parseDFA(std::istream& input) const {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type != AutomatonFromStringLexer::TokenType::DFA) {
 		throw exception::AlibException("Unrecognised DFA token.");
 	}
 	std::vector<alphabet::Symbol> symbols;
 
-	token = m_FiniteAutomatonLexer.next(input);
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		m_FiniteAutomatonLexer.putback(input, token);
+	token = m_AutomatonLexer.next(input);
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		m_AutomatonLexer.putback(input, token);
 		alphabet::Symbol symbol = alib::stringApi<alphabet::Symbol>::parse(input);
 		symbols.push_back(symbol);
 
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	State* initialState = NULL;
@@ -212,17 +212,17 @@ DFA FiniteAutomatonFromStringParser::parseDFA(std::istream& input) const {
 	std::set<std::tuple<State, alphabet::Symbol, State>> transitionFunction;
 
 	parseDFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-	token = m_FiniteAutomatonLexer.next(input);
+	token = m_AutomatonLexer.next(input);
 
-	while(token.type == FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
-		token = m_FiniteAutomatonLexer.next(input);
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::TEOF)
+	while(token.type == AutomatonFromStringLexer::TokenType::NEW_LINE) {
+		token = m_AutomatonLexer.next(input);
+		if(token.type == AutomatonFromStringLexer::TokenType::TEOF)
 			break;
 		else
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 
 		parseDFATransition(input, states, symbols, initialState, finalStates, transitionFunction);
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 	}
 
 	if(initialState == NULL) throw exception::AlibException("No initial state recognised.");
@@ -240,36 +240,36 @@ DFA FiniteAutomatonFromStringParser::parseDFA(std::istream& input) const {
 	return res;
 }
 
-void FiniteAutomatonFromStringParser::initialFinalState(std::istream& input, bool& initial, bool& final) const {
+void AutomatonFromStringParser::initialFinalState(std::istream& input, bool& initial, bool& final) const {
 	initial = false;
 	final = false;
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
-	if(token.type == FiniteAutomatonFromStringLexer::TokenType::IN) {
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
+	if(token.type == AutomatonFromStringLexer::TokenType::IN) {
 		initial = true;
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::OUT) {
+		if(token.type == AutomatonFromStringLexer::TokenType::OUT) {
 			final = true;
 		} else {
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 		}
-	} else if(token.type == FiniteAutomatonFromStringLexer::TokenType::OUT) {
+	} else if(token.type == AutomatonFromStringLexer::TokenType::OUT) {
 		final = true;
-		token = m_FiniteAutomatonLexer.next(input);
+		token = m_AutomatonLexer.next(input);
 
-		if(token.type == FiniteAutomatonFromStringLexer::TokenType::IN) {
+		if(token.type == AutomatonFromStringLexer::TokenType::IN) {
 			initial = true;
 		} else {
-			m_FiniteAutomatonLexer.putback(input, token);
+			m_AutomatonLexer.putback(input, token);
 		}
 	} else {
-		m_FiniteAutomatonLexer.putback(input, token);
+		m_AutomatonLexer.putback(input, token);
 	}
 }
 
 
-void FiniteAutomatonFromStringParser::parseEpsilonNFATransition(std::istream& input, std::set<State>& states, const std::vector<std::variant<string::Epsilon, alphabet::Symbol>>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, State>>& transitionFunction) const {
+void AutomatonFromStringParser::parseEpsilonNFATransition(std::istream& input, std::set<State>& states, const std::vector<std::variant<string::Epsilon, alphabet::Symbol>>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, std::variant<string::Epsilon, alphabet::Symbol>, State>>& transitionFunction) const {
 	bool initial = false;
 	bool final = false;
 
@@ -283,33 +283,33 @@ void FiniteAutomatonFromStringParser::parseEpsilonNFATransition(std::istream& in
 	}
 	if(final) finalStates.insert(from);
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
 	std::vector<std::variant<string::Epsilon, alphabet::Symbol>>::const_iterator iter = symbols.begin();
 
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
 		if(iter == symbols.end()) throw exception::AlibException("Invalid line format");
 
-		if(token.type != FiniteAutomatonFromStringLexer::TokenType::NONE) {
-			m_FiniteAutomatonLexer.putback(input, token);
+		if(token.type != AutomatonFromStringLexer::TokenType::NONE) {
+			m_AutomatonLexer.putback(input, token);
 			do {
 				State to(alib::stringApi<label::Label>::parse(input));
 				states.insert(to);
 				transitionFunction.insert(std::make_tuple(from, *iter, to));
 
-				token = m_FiniteAutomatonLexer.next(input);
-				if(token.type != FiniteAutomatonFromStringLexer::TokenType::SEPARATOR) break;
+				token = m_AutomatonLexer.next(input);
+				if(token.type != AutomatonFromStringLexer::TokenType::SEPARATOR) break;
 			} while(true);
 		} else {
-			token = m_FiniteAutomatonLexer.next(input);
+			token = m_AutomatonLexer.next(input);
 		}
 		iter++;
 	}
-	m_FiniteAutomatonLexer.putback(input, token);
+	m_AutomatonLexer.putback(input, token);
 
 	if(iter != symbols.end()) throw exception::AlibException("Invalid line format");
 }
 
-void FiniteAutomatonFromStringParser::parseMultiInitialStateNFATransition(std::istream& input, MultiInitialStateNFA& res, const std::vector<alphabet::Symbol>& symbols) const {
+void AutomatonFromStringParser::parseMultiInitialStateNFATransition(std::istream& input, MultiInitialStateNFA& res, const std::vector<alphabet::Symbol>& symbols) const {
 	bool initial = false;
 	bool final = false;
 
@@ -320,33 +320,33 @@ void FiniteAutomatonFromStringParser::parseMultiInitialStateNFATransition(std::i
 	if(initial) res.addInitialState(from);
 	if(final) res.addFinalState(from);
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
 	std::vector<alphabet::Symbol>::const_iterator iter = symbols.begin();
 
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
 		if(iter == symbols.end()) throw exception::AlibException("Invalid line format");
 
-		if(token.type != FiniteAutomatonFromStringLexer::TokenType::NONE) {
-			m_FiniteAutomatonLexer.putback(input, token);
+		if(token.type != AutomatonFromStringLexer::TokenType::NONE) {
+			m_AutomatonLexer.putback(input, token);
 			do {
 				State to(alib::stringApi<label::Label>::parse(input));
 				res.addState(to);
 				res.addTransition(from, *iter, to);
 
-				token = m_FiniteAutomatonLexer.next(input);
-				if(token.type != FiniteAutomatonFromStringLexer::TokenType::SEPARATOR) break;
+				token = m_AutomatonLexer.next(input);
+				if(token.type != AutomatonFromStringLexer::TokenType::SEPARATOR) break;
 			} while(true);
 		} else {
-			token = m_FiniteAutomatonLexer.next(input);
+			token = m_AutomatonLexer.next(input);
 		}
 		iter++;
 	}
-	m_FiniteAutomatonLexer.putback(input, token);
+	m_AutomatonLexer.putback(input, token);
 
 	if(iter != symbols.end()) throw exception::AlibException("Invalid line format");
 }
 
-void FiniteAutomatonFromStringParser::parseNFATransition(std::istream& input, std::set<State>& states, const std::vector<alphabet::Symbol>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, alphabet::Symbol, State>>& transitionFunction) const {
+void AutomatonFromStringParser::parseNFATransition(std::istream& input, std::set<State>& states, const std::vector<alphabet::Symbol>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, alphabet::Symbol, State>>& transitionFunction) const {
 	bool initial = false;
 	bool final = false;
 
@@ -360,33 +360,33 @@ void FiniteAutomatonFromStringParser::parseNFATransition(std::istream& input, st
 	}
 	if(final) finalStates.insert(from);
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
 	std::vector<alphabet::Symbol>::const_iterator iter = symbols.begin();
 
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
 		if(iter == symbols.end()) throw exception::AlibException("Invalid line format");
 
-		if(token.type != FiniteAutomatonFromStringLexer::TokenType::NONE) {
-			m_FiniteAutomatonLexer.putback(input, token);
+		if(token.type != AutomatonFromStringLexer::TokenType::NONE) {
+			m_AutomatonLexer.putback(input, token);
 			do {
 				State to(alib::stringApi<label::Label>::parse(input));
 				states.insert(to);
 				transitionFunction.insert(std::make_tuple(from, *iter, to));
 
-				token = m_FiniteAutomatonLexer.next(input);
-				if(token.type != FiniteAutomatonFromStringLexer::TokenType::SEPARATOR) break;
+				token = m_AutomatonLexer.next(input);
+				if(token.type != AutomatonFromStringLexer::TokenType::SEPARATOR) break;
 			} while(true);
 		} else {
-			token = m_FiniteAutomatonLexer.next(input);
+			token = m_AutomatonLexer.next(input);
 		}
 		iter++;
 	}
-	m_FiniteAutomatonLexer.putback(input, token);
+	m_AutomatonLexer.putback(input, token);
 
 	if(iter != symbols.end()) throw exception::AlibException("Invalid line format");
 }
 
-void FiniteAutomatonFromStringParser::parseDFATransition(std::istream& input, std::set<State>& states, const std::vector<alphabet::Symbol>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, alphabet::Symbol, State>>& transitionFunction) const {
+void AutomatonFromStringParser::parseDFATransition(std::istream& input, std::set<State>& states, const std::vector<alphabet::Symbol>& symbols, State*& initialState, std::set<State>& finalStates, std::set<std::tuple<State, alphabet::Symbol, State>>& transitionFunction) const {
 	bool initial = false;
 	bool final = false;
 
@@ -400,25 +400,25 @@ void FiniteAutomatonFromStringParser::parseDFATransition(std::istream& input, st
 	}
 	if(final) finalStates.insert(from);
 
-	FiniteAutomatonFromStringLexer::Token token = m_FiniteAutomatonLexer.next(input);
+	AutomatonFromStringLexer::Token token = m_AutomatonLexer.next(input);
 	std::vector<alphabet::Symbol>::const_iterator iter = symbols.begin();
 
-	while(token.type != FiniteAutomatonFromStringLexer::TokenType::NEW_LINE) {
+	while(token.type != AutomatonFromStringLexer::TokenType::NEW_LINE) {
 		if(iter == symbols.end()) throw exception::AlibException("Invalid line format");
 
-		if(token.type != FiniteAutomatonFromStringLexer::TokenType::NONE) {
-			m_FiniteAutomatonLexer.putback(input, token);
+		if(token.type != AutomatonFromStringLexer::TokenType::NONE) {
+			m_AutomatonLexer.putback(input, token);
 			State to(alib::stringApi<label::Label>::parse(input));
 			states.insert(to);
 			transitionFunction.insert(std::make_tuple(from, *iter, to));
 
-			token = m_FiniteAutomatonLexer.next(input);
+			token = m_AutomatonLexer.next(input);
 		} else {
-			token = m_FiniteAutomatonLexer.next(input);
+			token = m_AutomatonLexer.next(input);
 		}
 		iter++;
 	}
-	m_FiniteAutomatonLexer.putback(input, token);
+	m_AutomatonLexer.putback(input, token);
 
 	if(iter != symbols.end()) throw exception::AlibException("Invalid line format");
 }
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.h b/alib2data/src/automaton/AutomatonFromStringParser.h
similarity index 77%
rename from alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.h
rename to alib2data/src/automaton/AutomatonFromStringParser.h
index c2b1ae1735..8f6289449e 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonFromStringParser.h
+++ b/alib2data/src/automaton/AutomatonFromStringParser.h
@@ -1,22 +1,22 @@
 /*
- * FiniteAutomatonFromStringParser.h
+ * AutomatonFromStringParser.h
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#ifndef FINITE_AUTOMATON_FROM_STRING_PARSER_H_
-#define FINITE_AUTOMATON_FROM_STRING_PARSER_H_
+#ifndef AUTOMATON_FROM_STRING_PARSER_H_
+#define AUTOMATON_FROM_STRING_PARSER_H_
 
-#include "FiniteAutomatonFromStringLexer.h"
+#include "AutomatonFromStringLexer.h"
 
-#include "../Automaton.h"
-#include "../AutomatonFeatures.h"
-#include "../common/State.h"
+#include "Automaton.h"
+#include "AutomatonFeatures.h"
+#include "common/State.h"
 
 #include <tuple>
-#include "../../std/variant.hpp"
-#include "../../string/Epsilon.h"
+#include "../std/variant.hpp"
+#include "../string/Epsilon.h"
 
 namespace alib {
 
@@ -27,8 +27,8 @@ struct stringApi;
 
 namespace automaton {
 
-class FiniteAutomatonFromStringParser {
-	FiniteAutomatonFromStringLexer m_FiniteAutomatonLexer;
+class AutomatonFromStringParser {
+	AutomatonFromStringLexer m_AutomatonLexer;
 
 	void initialFinalState(std::istream& input, bool& initial, bool& final) const;
 
@@ -50,4 +50,4 @@ class FiniteAutomatonFromStringParser {
 
 } /* namespace automaton */
 
-#endif /* FINITE_AUTOMATON_FROM_STRING_PARSER_H_ */
+#endif /* AUTOMATON_FROM_STRING_PARSER_H_ */
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.cpp b/alib2data/src/automaton/AutomatonToStringComposer.cpp
similarity index 69%
rename from alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.cpp
rename to alib2data/src/automaton/AutomatonToStringComposer.cpp
index 7fd35170a7..8362e48db3 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.cpp
+++ b/alib2data/src/automaton/AutomatonToStringComposer.cpp
@@ -1,18 +1,18 @@
 /*
- * FiniteAutomatonToStringComposer.cpp
+ * AutomatonToStringComposer.cpp
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#include "FiniteAutomatonToStringComposer.h"
-#include "../../exception/AlibException.h"
+#include "AutomatonToStringComposer.h"
+#include "../exception/AlibException.h"
 
-#include "../../StringApi.hpp"
+#include "../StringApi.hpp"
 
 namespace automaton {
 
-void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const DFA& automaton, const State& from) const {
+void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const DFA& automaton, const State& from) const {
 	std::map<std::pair<State, alphabet::Symbol>, State> symbolTransitionsFromState = automaton.getTransitionsFromState(from);
 
 	for(const alphabet::Symbol& inputSymbol : automaton.getInputAlphabet()) {
@@ -26,7 +26,7 @@ void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream&
 	}
 }
 
-void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const NFA& automaton, const State& from) const {
+void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const NFA& automaton, const State& from) const {
 	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
 
 	for(const alphabet::Symbol& inputSymbol : automaton.getInputAlphabet()) {
@@ -44,7 +44,7 @@ void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream&
 	}
 }
 
-void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const MultiInitialStateNFA& automaton, const State& from) const {
+void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const MultiInitialStateNFA& automaton, const State& from) const {
 	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > symbolTransitionsFromState = automaton.getTransitionsFromState(from);
 
 	for(const alphabet::Symbol& inputSymbol : automaton.getInputAlphabet()) {
@@ -62,7 +62,7 @@ void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream&
 	}
 }
 
-void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const EpsilonNFA& automaton, const State& from) const {
+void AutomatonToStringComposer::composeTransitionsFromState(std::ostream& out, const EpsilonNFA& automaton, const State& from) const {
 	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > symbolTransitionsFromState = automaton.getSymbolTransitionsFromState(from);
 
 	for(const alphabet::Symbol& inputSymbol : automaton.getInputAlphabet()) {
@@ -92,7 +92,7 @@ void FiniteAutomatonToStringComposer::composeTransitionsFromState(std::ostream&
 	}
 }
 
-void FiniteAutomatonToStringComposer::compose(std::ostream& out, const DFA& automaton) const {
+void AutomatonToStringComposer::compose(std::ostream& out, const DFA& automaton) const {
 	out << "DFA";
 	for(const auto& symbol : automaton.getInputAlphabet()) {
 		out << " ";
@@ -116,7 +116,7 @@ void FiniteAutomatonToStringComposer::compose(std::ostream& out, const DFA& auto
 	}
 }
 
-void FiniteAutomatonToStringComposer::compose(std::ostream& out, const NFA& automaton) const {
+void AutomatonToStringComposer::compose(std::ostream& out, const NFA& automaton) const {
 	out << "NFA";
 	for(const auto& symbol : automaton.getInputAlphabet()) {
 		out << " ";
@@ -140,7 +140,7 @@ void FiniteAutomatonToStringComposer::compose(std::ostream& out, const NFA& auto
 	}
 }
 
-void FiniteAutomatonToStringComposer::compose(std::ostream& out, const MultiInitialStateNFA& automaton) const {
+void AutomatonToStringComposer::compose(std::ostream& out, const MultiInitialStateNFA& automaton) const {
 	out << "MISNFA";
 	for(const auto& symbol : automaton.getInputAlphabet()) {
 		out << " ";
@@ -164,7 +164,7 @@ void FiniteAutomatonToStringComposer::compose(std::ostream& out, const MultiInit
 	}
 }
 
-void FiniteAutomatonToStringComposer::compose(std::ostream& out, const EpsilonNFA& automaton) const {
+void AutomatonToStringComposer::compose(std::ostream& out, const EpsilonNFA& automaton) const {
 	out << "ENFA";
 	for(const auto& symbol : automaton.getInputAlphabet()) {
 		out << " ";
@@ -189,75 +189,75 @@ void FiniteAutomatonToStringComposer::compose(std::ostream& out, const EpsilonNF
 	}
 }
 
-void FiniteAutomatonToStringComposer::compose(std::ostream& output, const Automaton& automaton) const {
+void AutomatonToStringComposer::compose(std::ostream& output, const Automaton& automaton) const {
 	automaton.getData().Accept((void*) &output, *this);
 }
 
-void FiniteAutomatonToStringComposer::Visit(void* data, const EpsilonNFA& automaton) const {
+void AutomatonToStringComposer::Visit(void* data, const EpsilonNFA& automaton) const {
 	this->compose(*((std::ostream*) data), automaton);
 }
 
-void FiniteAutomatonToStringComposer::Visit(void* data, const MultiInitialStateNFA& automaton) const {
+void AutomatonToStringComposer::Visit(void* data, const MultiInitialStateNFA& automaton) const {
 	this->compose(*((std::ostream*) data), automaton);
 }
 
-void FiniteAutomatonToStringComposer::Visit(void* data, const NFA& automaton) const {
+void AutomatonToStringComposer::Visit(void* data, const NFA& automaton) const {
 	this->compose(*((std::ostream*) data), automaton);
 }
 
-void FiniteAutomatonToStringComposer::Visit(void* data, const DFA& automaton) const {
+void AutomatonToStringComposer::Visit(void* data, const DFA& automaton) const {
 	this->compose(*((std::ostream*) data), automaton);
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const ExtendedNFA&) const {
+void AutomatonToStringComposer::Visit(void*, const ExtendedNFA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const CompactNFA&) const {
+void AutomatonToStringComposer::Visit(void*, const CompactNFA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const DPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const DPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const SinglePopDPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const SinglePopDPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const InputDrivenDPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const InputDrivenDPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const InputDrivenNPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const InputDrivenNPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const VisiblyPushdownDPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const VisiblyPushdownDPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const VisiblyPushdownNPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const VisiblyPushdownNPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const RealTimeHeightDeterministicDPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const RealTimeHeightDeterministicDPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const RealTimeHeightDeterministicNPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const RealTimeHeightDeterministicNPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const NPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const NPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const SinglePopNPDA&) const {
+void AutomatonToStringComposer::Visit(void*, const SinglePopNPDA&) const {
 	throw exception::AlibException();
 }
 
-void FiniteAutomatonToStringComposer::Visit(void*, const OneTapeDTM&) const {
+void AutomatonToStringComposer::Visit(void*, const OneTapeDTM&) const {
 	throw exception::AlibException();
 }
 
diff --git a/alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.h b/alib2data/src/automaton/AutomatonToStringComposer.h
similarity index 85%
rename from alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.h
rename to alib2data/src/automaton/AutomatonToStringComposer.h
index 394f801137..d520fcfc6a 100644
--- a/alib2data/src/automaton/FSM/FiniteAutomatonToStringComposer.h
+++ b/alib2data/src/automaton/AutomatonToStringComposer.h
@@ -1,23 +1,23 @@
 /*
- * FiniteAutomatonToStringComposer.cpp
+ * AutomatonToStringComposer.cpp
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#ifndef AUTOMATON_PRINTER_H_
-#define AUTOMATON_PRINTER_H_
+#ifndef AUTOMATON_TO_STRING_COMPOSER_H_
+#define AUTOMATON_TO_STRING_COMPOSER_H_
 
 #include <sstream>
-#include "../Automaton.h"
-#include "DFA.h"
-#include "NFA.h"
-#include "MultiInitialStateNFA.h"
-#include "EpsilonNFA.h"
+#include "Automaton.h"
+#include "FSM/DFA.h"
+#include "FSM/NFA.h"
+#include "FSM/MultiInitialStateNFA.h"
+#include "FSM/EpsilonNFA.h"
 
 namespace automaton {
 
-class FiniteAutomatonToStringComposer : public VisitableAutomatonBase::const_visitor_type {
+class AutomatonToStringComposer : public VisitableAutomatonBase::const_visitor_type {
 	void Visit(void*, const EpsilonNFA& automaton) const;
 	void Visit(void*, const MultiInitialStateNFA& automaton) const;
 	void Visit(void*, const NFA& automaton) const;
@@ -59,4 +59,4 @@ public:
 
 } /* namespace automaton */
 
-#endif /* AUTOMATON_PRINTER_H_ */
+#endif /* AUTOMATON_TO_STRING_COMPOSER_H_ */
-- 
GitLab