AutomatonFromTo -> UnknownAutomatonFromTo

alib2/src/automaton/AutomatonFromXMLParser.cpp → alib2/src/automaton/UnknownAutomatonFromXMLParser.cpp

 /*
- * AutomatonFromXMLParser.cpp
+ * UnknownAutomatonFromXMLParser.cpp
  *
  *  Created on: Oct 12, 2013
  *      Author: Martin Zak
  */
-#include "AutomatonFromXMLParser.h"
+#include "UnknownAutomatonFromXMLParser.h"
 #include "../sax/ParserException.h"
 #include "../alphabet/Blank.h"
 namespace automaton {
-UnknownAutomaton AutomatonFromXMLParser::parse(std::list<sax::Token> &input) {
+UnknownAutomaton UnknownAutomatonFromXMLParser::parse(std::list<sax::Token> &input) {
 	UnknownAutomaton automaton;
 	popToken(input, sax::Token::START_ELEMENT, "automaton");
@@ -46,7 +46,7 @@ UnknownAutomaton AutomatonFromXMLParser::parse(std::list<sax::Token> &input) {
 	return automaton;
 }
-void AutomatonFromXMLParser::parseStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "states");
 	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
 		automaton.addState(parseState(input, "state"));
@@ -54,7 +54,7 @@ void AutomatonFromXMLParser::parseStates(std::list<sax::Token> &input, UnknownAu
 	popToken(input, sax::Token::END_ELEMENT, "states");
 }
-void AutomatonFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "inputAlphabet");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		automaton.addInputSymbol(parseSymbol(input));
@@ -62,7 +62,7 @@ void AutomatonFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input, Un
 	popToken(input, sax::Token::END_ELEMENT, "inputAlphabet");
 }
-void AutomatonFromXMLParser::parseInitialStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseInitialStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "initialStates");
 	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
 		automaton.addInitialState(parseState(input, "state"));
@@ -70,7 +70,7 @@ void AutomatonFromXMLParser::parseInitialStates(std::list<sax::Token> &input, Un
 	popToken(input, sax::Token::END_ELEMENT, "initialStates");
 }
-void AutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "finalStates");
 	while (isToken(input, sax::Token::START_ELEMENT, "state")) {
 		automaton.addFinalState(parseState(input, "state"));
@@ -78,7 +78,7 @@ void AutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &input, Unkn
 	popToken(input, sax::Token::END_ELEMENT, "finalStates");
 }
-void AutomatonFromXMLParser::parseStackAlphabet(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseStackAlphabet(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "stackAlphabet");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		automaton.addStackSymbol(parseSymbol(input));
@@ -86,7 +86,7 @@ void AutomatonFromXMLParser::parseStackAlphabet(std::list<sax::Token> &input, Un
 	popToken(input, sax::Token::END_ELEMENT, "stackAlphabet");
 }
-void AutomatonFromXMLParser::parseStartSymbols(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseStartSymbols(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "startSymbols");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		automaton.addInitialSymbol(parseSymbol(input));
@@ -94,7 +94,7 @@ void AutomatonFromXMLParser::parseStartSymbols(std::list<sax::Token> &input, Unk
 	popToken(input, sax::Token::END_ELEMENT, "startSymbols");
 }
-void AutomatonFromXMLParser::parseTapeAlphabet(std::list<sax::Token>& input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseTapeAlphabet(std::list<sax::Token>& input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "tapeAlphabet");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		automaton.addTapeSymbol(parseSymbol(input));
@@ -102,13 +102,13 @@ void AutomatonFromXMLParser::parseTapeAlphabet(std::list<sax::Token>& input, Unk
 	popToken(input, sax::Token::END_ELEMENT, "tapeAlphabet");
 }
-void AutomatonFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "blankSymbol");
 	automaton.setBlankSymbol(parseSymbol(input));
 	popToken(input, sax::Token::END_ELEMENT, "blankSymbol");
 }
-void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
+void UnknownAutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, UnknownAutomaton& automaton) {
 	popToken(input, sax::Token::START_ELEMENT, "transitions");
 	while (isToken(input, sax::Token::START_ELEMENT, "transition")) {
 		automaton.addTransition(parseTransition(input));
@@ -116,7 +116,7 @@ void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, Unkn
 	popToken(input, sax::Token::END_ELEMENT, "transitions");
 }
-void AutomatonFromXMLParser::parsePop(std::list<sax::Token>& input, UnknownTransition& transition) {
+void UnknownAutomatonFromXMLParser::parsePop(std::list<sax::Token>& input, UnknownTransition& transition) {
 	popToken(input, sax::Token::START_ELEMENT, "pop");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		transition.addPop(parseSymbol(input));
@@ -124,7 +124,7 @@ void AutomatonFromXMLParser::parsePop(std::list<sax::Token>& input, UnknownTrans
 	popToken(input, sax::Token::END_ELEMENT, "pop");
 }
-void AutomatonFromXMLParser::parsePush(std::list<sax::Token>& input, UnknownTransition& transition) {
+void UnknownAutomatonFromXMLParser::parsePush(std::list<sax::Token>& input, UnknownTransition& transition) {
 	popToken(input, sax::Token::START_ELEMENT, "push");
 	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		transition.addPush(parseSymbol(input));
@@ -132,7 +132,7 @@ void AutomatonFromXMLParser::parsePush(std::list<sax::Token>& input, UnknownTran
 	popToken(input, sax::Token::END_ELEMENT, "push");
 }
-State AutomatonFromXMLParser::parseState(std::list<sax::Token> &input, std::string tagName) {
+State UnknownAutomatonFromXMLParser::parseState(std::list<sax::Token> &input, std::string tagName) {
 	popToken(input, sax::Token::START_ELEMENT, tagName);
 	State state(popTokenData(input, sax::Token::CHARACTER));
@@ -140,7 +140,7 @@ State AutomatonFromXMLParser::parseState(std::list<sax::Token> &input, std::stri
 	return state;
 }
-alphabet::Symbol AutomatonFromXMLParser::parseSymbol(std::list<sax::Token>& input) {
+alphabet::Symbol UnknownAutomatonFromXMLParser::parseSymbol(std::list<sax::Token>& input) {
 	alphabet::Symbol result("");
 	if (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
 		popToken(input, sax::Token::START_ELEMENT, "symbol");
@@ -156,7 +156,7 @@ alphabet::Symbol AutomatonFromXMLParser::parseSymbol(std::list<sax::Token>& inpu
 	return result;
 }
-std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseInput(std::list<sax::Token>& input, std::string tagName) {
+std::variant<string::Epsilon, alphabet::Symbol> UnknownAutomatonFromXMLParser::parseInput(std::list<sax::Token>& input, std::string tagName) {
 	popToken(input, sax::Token::START_ELEMENT, tagName);
 	std::variant<string::Epsilon, alphabet::Symbol> result;
@@ -178,7 +178,7 @@ std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseInp
 	return result;
 }
-Shift AutomatonFromXMLParser::parseShift(std::list<sax::Token>& input) {
+Shift UnknownAutomatonFromXMLParser::parseShift(std::list<sax::Token>& input) {
 	Shift shift;
 	popToken(input, sax::Token::START_ELEMENT, "shift");
@@ -199,7 +199,7 @@ Shift AutomatonFromXMLParser::parseShift(std::list<sax::Token>& input) {
 	return shift;
 }
-UnknownTransition AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input) {
+UnknownTransition UnknownAutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input) {
 	UnknownTransition transition;
 	popToken(input, sax::Token::START_ELEMENT, "transition");

alib2/src/automaton/AutomatonFromXMLParser.h → alib2/src/automaton/UnknownAutomatonFromXMLParser.h

 /*
- * AutomatonFromXMLParser.h
+ * UnknownAutomatonFromXMLParser.h
  *
  *  Created on: Oct 12, 2013
  *      Author: Martin Zak
  */
-#ifndef AUTOMATON_FROM_XML_PARSER_H_
-#define AUTOMATON_FROM_XML_PARSER_H_
+#ifndef UNKNOWN_AUTOMATON_FROM_XML_PARSER_H_
+#define UNKNOWN_AUTOMATON_FROM_XML_PARSER_H_
 #include "../sax/FromXMLParser.h"
 #include "UnknownAutomaton.h"
@@ -22,7 +22,7 @@ namespace automaton {
 /**
  * Parser used to get UnknownAutomaton from XML parsed into list of Tokens.
  */
-class AutomatonFromXMLParser : public sax::FromXMLParser {
+class UnknownAutomatonFromXMLParser : public sax::FromXMLParser {
 protected:
 	void parseStates(std::list<sax::Token> &input, UnknownAutomaton& automaton);
 	void parseInputAlphabet(std::list<sax::Token> &input, UnknownAutomaton& automaton);
@@ -55,5 +55,5 @@ public:
 } /* namespace automaton */
-#endif /* AUTOMATON_FROM_XML_PARSER_H_ */
+#endif /* UNKNOWN_AUTOMATON_FROM_XML_PARSER_H_ */

alib2/src/automaton/AutomatonToXMLComposer.cpp → alib2/src/automaton/UnknownAutomatonToXMLComposer.cpp

 /*
- * AutomatonToXMLComposer.cpp
+ * UnknownAutomatonToXMLComposer.cpp
  *
  *  Created on: Nov 11, 2013
  *      Author: martin
  */
-#include "AutomatonToXMLComposer.h"
+#include "UnknownAutomatonToXMLComposer.h"
 namespace automaton {
-void AutomatonToXMLComposer::printStates(std::list<sax::Token>& out, const std::set<State>& states, std::string tagName) {
+void UnknownAutomatonToXMLComposer::printStates(std::list<sax::Token>& out, const std::set<State>& states, std::string tagName) {
 	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
 	for (auto& state : states) {
 		printState(out, state, "state");
@@ -17,7 +17,7 @@ void AutomatonToXMLComposer::printStates(std::list<sax::Token>& out, const std::
 	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
 }
-void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& alphabet, std::string tagName) {
+void UnknownAutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& alphabet, std::string tagName) {
 	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
 	for (auto& symbol : alphabet) {
 		printSymbol(out, symbol, "symbol");
@@ -25,7 +25,7 @@ void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std:
 	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
 }
-void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& alphabet, std::string tagName) {
+void UnknownAutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& alphabet, std::string tagName) {
 	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
 	for (auto& symbol : alphabet) {
 		printSymbol(out, symbol, "symbol");
@@ -33,7 +33,7 @@ void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std:
 	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
 }
-void AutomatonToXMLComposer::printUnknownTransitions(std::list<sax::Token>& out, const std::set<UnknownTransition>& transitions) {
+void UnknownAutomatonToXMLComposer::printUnknownTransitions(std::list<sax::Token>& out, const std::set<UnknownTransition>& transitions) {
 	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
 	for (auto& transition : transitions) {
 		out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
@@ -71,13 +71,13 @@ void AutomatonToXMLComposer::printUnknownTransitions(std::list<sax::Token>& out,
 	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
 }
-void AutomatonToXMLComposer::printState(std::list<sax::Token>& out, const State& state, std::string tagName) {
+void UnknownAutomatonToXMLComposer::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 AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol, std::string tagName) {
+void UnknownAutomatonToXMLComposer::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));
@@ -91,7 +91,7 @@ void AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const std::v
 	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
 }
-void AutomatonToXMLComposer::printSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) {
+void UnknownAutomatonToXMLComposer::printSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) {
 	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));
@@ -102,13 +102,13 @@ void AutomatonToXMLComposer::printSymbol(std::list<sax::Token>& out, const alpha
 	}
 }
-void AutomatonToXMLComposer::printShift(std::list<sax::Token>& out, const Shift& shift, std::string tagName) {
+void UnknownAutomatonToXMLComposer::printShift(std::list<sax::Token>& out, const Shift& shift, std::string tagName) {
 	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
 	out.push_back(sax::Token(SHIFT_NAMES [shift], sax::Token::CHARACTER));
 	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
 }
-std::list<sax::Token> AutomatonToXMLComposer::compose(const UnknownAutomaton& automaton) {
+std::list<sax::Token> UnknownAutomatonToXMLComposer::compose(const UnknownAutomaton& automaton) {
 	std::list<sax::Token> out;
 	out.push_back(sax::Token("automaton", sax::Token::START_ELEMENT));

alib2/src/automaton/AutomatonToXMLComposer.h → alib2/src/automaton/UnknownAutomatonToXMLComposer.h

 /*
- * AutomatonToXMLComposer.h
+ * UnknownAutomatonToXMLComposer.h
  *
  *  Created on: Nov 11, 2013
  *      Author: Jan Travnicek
  */
-#ifndef AUTOMATON_TO_XML_COMPOSER_H_
-#define AUTOMATON_TO_XML_COMPOSER_H_
+#ifndef UNKNOWN_AUTOMATON_TO_XML_COMPOSER_H_
+#define UNKNOWN_AUTOMATON_TO_XML_COMPOSER_H_
 #include <string>
 #include "UnknownAutomaton.h"
@@ -18,7 +18,7 @@ namespace automaton {
 /**
  * This class contains methods to print XML representation of automata to the output stream.
  */
-class AutomatonToXMLComposer {
+class UnknownAutomatonToXMLComposer {
 protected:
 	static void printStates(std::list<sax::Token>&, const std::set<State>& states, std::string tagName);
 	static void printSymbols(std::list<sax::Token>&, const std::set<alphabet::Symbol>& alphabet, std::string tagName);

alib2/src/factory/AutomatonFactory.cpp

@@ -9,8 +9,8 @@
 #include "../sax/SaxParseInterface.h"
 #include "../sax/SaxComposeInterface.h"
-#include "../automaton/AutomatonFromXMLParser.h"
-#include "../automaton/AutomatonToXMLComposer.h"
+#include "../automaton/UnknownAutomatonFromXMLParser.h"
+#include "../automaton/UnknownAutomatonToXMLComposer.h"
 namespace automaton {
@@ -36,7 +36,7 @@ UnknownAutomaton AutomatonFactory::fromStream(std::istream& in) {
 }
 UnknownAutomaton AutomatonFactory::parse(std::list<sax::Token> tokens) {
-	AutomatonFromXMLParser parser;
+	UnknownAutomatonFromXMLParser parser;
 	return parser.parse(tokens);
 }
@@ -62,7 +62,7 @@ void AutomatonFactory::toStream(const UnknownAutomaton& regexp, std::ostream& ou
 }
 std::list<sax::Token> AutomatonFactory::compose(const UnknownAutomaton& automaton) {
-	AutomatonToXMLComposer composer;
+	UnknownAutomatonToXMLComposer composer;
 	return composer.compose(automaton);
 }

alib2/test-src/automaton/AutomatonTest.cpp

@@ -5,8 +5,8 @@
 #include "sax/SaxComposeInterface.h"
 #include "automaton/UnknownAutomaton.h"
-#include "automaton/AutomatonFromXMLParser.h"
-#include "automaton/AutomatonToXMLComposer.h"
+#include "automaton/UnknownAutomatonFromXMLParser.h"
+#include "automaton/UnknownAutomatonToXMLComposer.h"
 #include "automaton/FSM/DFA.h"
 #include "automaton/FSM/FSMFromXMLParser.h"
@@ -32,14 +32,14 @@ void AutomatonTest::testXMLParser() {
   
   CPPUNIT_ASSERT( automaton == automaton );
   {
-	automaton::AutomatonToXMLComposer composer;
+	automaton::UnknownAutomatonToXMLComposer composer;
 	std::list<sax::Token> tokens = composer.compose(automaton);
 	std::string tmp;
 	sax::SaxComposeInterface::printMemory(tmp, tokens);
   
 	std::list<sax::Token> tokens2;
 	sax::SaxParseInterface::parseMemory(tmp, tokens2);
-	automaton::AutomatonFromXMLParser parser;
+	automaton::UnknownAutomatonFromXMLParser parser;
 	automaton::UnknownAutomaton automaton2 = parser.parse(tokens2);
 	CPPUNIT_ASSERT( automaton == automaton2 );