diff --git a/alib2/src/ExceptionFromXMLParser.cpp b/alib2/src/ExceptionFromXMLParser.cpp
index 587f96002626821726bbb7569241c4bfd6dba940..fe361b432f8bd05c8baa430c53aacb85231eaeed 100644
--- a/alib2/src/ExceptionFromXMLParser.cpp
+++ b/alib2/src/ExceptionFromXMLParser.cpp
@@ -12,13 +12,13 @@
 namespace alib {
 
 AlibException ExceptionFromXMLParser::parse(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "exception");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "exception");
 	std::string cause = "";
-	if (input.front().getType() == sax::Token::CHARACTER) {
+	if (input.front().getType() == sax::Token::TokenType::CHARACTER) {
 		cause = input.front().getData();
 		input.pop_front();
 	}
-	popToken(input, sax::Token::END_ELEMENT, "exception");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "exception");
 	return AlibException(cause);
 }
 
diff --git a/alib2/src/ExceptionToXMLComposer.cpp b/alib2/src/ExceptionToXMLComposer.cpp
index 95c45fe59cc434901dfed22ff8657c6f66fd87c5..368765d318c8a2da13e4c38e1c7c5c69eb4687b2 100644
--- a/alib2/src/ExceptionToXMLComposer.cpp
+++ b/alib2/src/ExceptionToXMLComposer.cpp
@@ -12,9 +12,9 @@ namespace alib {
 void ExceptionToXMLComposer::Visit(void* userData, const AlibException& exception) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 	
-	out.push_back(sax::Token("exception", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token(exception.getCause(), sax::Token::CHARACTER));
-	out.push_back(sax::Token("exception", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("exception", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(exception.getCause(), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("exception", sax::Token::TokenType::END_ELEMENT));
 }
 
 std::list<sax::Token> ExceptionToXMLComposer::compose(const AlibException& exception) const {
diff --git a/alib2/src/alphabet/SymbolFromXMLParser.cpp b/alib2/src/alphabet/SymbolFromXMLParser.cpp
index eae1ec0f8a0ddeb1bfa583e4ea57fe317a35adb0..92bbfa6b419d37173e88b86dcfa28f6037653edd 100644
--- a/alib2/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2/src/alphabet/SymbolFromXMLParser.cpp
@@ -17,17 +17,17 @@
 namespace alphabet {
 
 Symbol SymbolFromXMLParser::parse(std::list<sax::Token>& input) const {
-	if(isToken(input, sax::Token::START_ELEMENT, "LabeledSymbol")) {
-		popToken(input, sax::Token::START_ELEMENT, "LabeledSymbol");
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol");
 		label::Label data = alib::FromXMLParsers::labelParser.parse(input);
-		popToken(input, sax::Token::END_ELEMENT, "LabeledSymbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "LabeledSymbol");
 		return Symbol(LabeledSymbol(data));
-	} else if(isToken(input, sax::Token::START_ELEMENT, "BlankSymbol")) {
-		popToken(input, sax::Token::START_ELEMENT, "BlankSymbol");
-		popToken(input, sax::Token::END_ELEMENT, "BlankSymbol");
+	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "BlankSymbol");
 		return Symbol(BlankSymbol());
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::START_ELEMENT), input.front());
 	}
 }
 
diff --git a/alib2/src/alphabet/SymbolToXMLComposer.cpp b/alib2/src/alphabet/SymbolToXMLComposer.cpp
index 94c457be3164df1e936d0f038d484b17115ad60c..f6a25fc10a8594d2ea87fdd8a628b23f7125d51c 100644
--- a/alib2/src/alphabet/SymbolToXMLComposer.cpp
+++ b/alib2/src/alphabet/SymbolToXMLComposer.cpp
@@ -15,16 +15,16 @@ namespace alphabet {
 void SymbolToXMLComposer::Visit(void* userData, const BlankSymbol&) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("BlankSymbol", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token("BlankSymbol", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("BlankSymbol", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token("BlankSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
 void SymbolToXMLComposer::Visit(void* userData, const LabeledSymbol& symbol) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("LabeledSymbol", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("LabeledSymbol", sax::Token::TokenType::START_ELEMENT));
 	out.splice(out.end(), alib::ToXMLComposers::labelComposer.compose(symbol.getLabel()));
-	out.push_back(sax::Token("LabeledSymbol", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("LabeledSymbol", sax::Token::TokenType::END_ELEMENT));
 }
 
 void SymbolToXMLComposer::Visit(void* userData, const Symbol& symbol) const {
diff --git a/alib2/src/automaton/AutomatonFromXMLParser.cpp b/alib2/src/automaton/AutomatonFromXMLParser.cpp
index cf739ee2a50b16e8546440db5c7e716b34314607..12d149bb70ea4f0c8ca2c298616518a5ae0d4338 100644
--- a/alib2/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2/src/automaton/AutomatonFromXMLParser.cpp
@@ -16,54 +16,54 @@
 namespace automaton {
 
 Automaton AutomatonFromXMLParser::parse(std::list<sax::Token> &input) const {
-	if(isToken(input, sax::Token::START_ELEMENT, "automaton"))
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "automaton"))
 		return Automaton(parseUnknownAutomaton(input));
-	else if(isToken(input, sax::Token::START_ELEMENT, "EpsilonNFA"))
+	else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA"))
 		return Automaton(parseEpsilonNFA(input));
-	else if(isToken(input, sax::Token::START_ELEMENT, "NFA"))
+	else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "NFA"))
 		return Automaton(parseNFA(input));
-	else if(isToken(input, sax::Token::START_ELEMENT, "DFA"))
+	else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "DFA"))
 		return Automaton(parseDFA(input));
 	else
-		throw sax::ParserException(sax::Token("EpsilonNFA / NFA / DFA", sax::Token::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("EpsilonNFA / NFA / DFA", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
 UnknownAutomaton AutomatonFromXMLParser::parseUnknownAutomaton(std::list<sax::Token> &input) const {
 	UnknownAutomaton automaton;
 
-	popToken(input, sax::Token::START_ELEMENT, "automaton");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "automaton");
 
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		if (isToken(input, sax::Token::START_ELEMENT, "states")) {
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		if (isToken(input, sax::Token::TokenType::START_ELEMENT, "states")) {
 			automaton.setStates(parseStates(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "inputAlphabet")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "inputAlphabet")) {
 			automaton.setInputSymbols(parseInputAlphabet(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "initialStates")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "initialStates")) {
 			automaton.setInitialStates(parseInitialStates(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "finalStates")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "finalStates")) {
 			automaton.setFinalStates(parseFinalStates(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "stackAlphabet")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "stackAlphabet")) {
 			automaton.setStackSymbols(parseStackAlphabet(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "startSymbols")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "startSymbols")) {
 			automaton.setInitialSymbols(parseInitialSymbols(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "tapeAlphabet")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "tapeAlphabet")) {
 			automaton.setTapeSymbols(parseTapeAlphabet(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "blankSymbol")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "blankSymbol")) {
 			automaton.setBlankSymbol(parseBlankSymbol(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "transitions")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "transitions")) {
 			parseTransitions(input, automaton);
 
 		} else {
-			throw sax::ParserException(sax::Token("automaton", sax::Token::END_ELEMENT), input.front());
+			throw sax::ParserException(sax::Token("automaton", sax::Token::TokenType::END_ELEMENT), input.front());
 		}
 	}
 
-	popToken(input, sax::Token::END_ELEMENT, "automaton");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "automaton");
 	return automaton;
 }
 
 DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "DFA");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "DFA");
 
 	std::set<State> states = parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -77,12 +77,12 @@ DFA AutomatonFromXMLParser::parseDFA(std::list<sax::Token>& input) const {
 
 	parseTransitions<DFA>(input, automaton);
 
-	popToken(input, sax::Token::END_ELEMENT, "DFA");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "DFA");
 	return automaton;
 }
 
 NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "NFA");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "NFA");
 
 	std::set<State> states = parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -97,12 +97,12 @@ NFA AutomatonFromXMLParser::parseNFA(std::list<sax::Token>& input) const {
 
 	parseTransitions<NFA>(input, automaton);
 
-	popToken(input, sax::Token::END_ELEMENT, "NFA");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "NFA");
 	return automaton;
 }
 
 EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "EpsilonNFA");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA");
 
 	std::set<State> states = parseStates(input);
 	std::set<alphabet::Symbol> inputSymbols = parseInputAlphabet(input);
@@ -117,130 +117,130 @@ EpsilonNFA AutomatonFromXMLParser::parseEpsilonNFA(std::list<sax::Token>& input)
 
 	parseTransitions<EpsilonNFA>(input, automaton);
 
-	popToken(input, sax::Token::END_ELEMENT, "EpsilonNFA");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "EpsilonNFA");
 	return automaton;
 }
 
 std::string AutomatonFromXMLParser::parseLabel(std::list<sax::Token>& input) const {
-	return popTokenData(input, sax::Token::CHARACTER);
+	return popTokenData(input, sax::Token::TokenType::CHARACTER);
 }
 
 std::set<State> AutomatonFromXMLParser::parseStates(std::list<sax::Token> &input) const {
 	std::set<State> states;
-	popToken(input, sax::Token::START_ELEMENT, "states");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "state");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "states");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "state");
 		states.insert(State(parseLabel(input)));
-		popToken(input, sax::Token::END_ELEMENT, "state");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "state");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "states");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "states");
 	return states;
 }
 
 std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInputAlphabet(std::list<sax::Token> &input) const {
 	std::set<alphabet::Symbol> inputSymbols;
-	popToken(input, sax::Token::START_ELEMENT, "inputAlphabet");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "inputAlphabet");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		inputSymbols.insert(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "inputAlphabet");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "inputAlphabet");
 	return inputSymbols;
 }
 
 State AutomatonFromXMLParser::parseInitialState(std::list<sax::Token> &input) const {
-	popToken(input, sax::Token::START_ELEMENT, "initialState");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialState");
 	State state = State(parseLabel(input));
-	popToken(input, sax::Token::END_ELEMENT, "initialState");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialState");
 	return state;
 }
 
 std::set<State> AutomatonFromXMLParser::parseInitialStates(std::list<sax::Token> &input) const {
 	std::set<State> initialStates;
-	popToken(input, sax::Token::START_ELEMENT, "initialStates");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "state");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialStates");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "state");
 		initialStates.insert(State(parseLabel(input)));
-		popToken(input, sax::Token::END_ELEMENT, "state");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "state");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "initialStates");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialStates");
 	return initialStates;
 }
 
 std::set<State> AutomatonFromXMLParser::parseFinalStates(std::list<sax::Token> &input) const {
 	std::set<State> finalStates;
-	popToken(input, sax::Token::START_ELEMENT, "finalStates");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "state");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "finalStates");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "state");
 		finalStates.insert(State(parseLabel(input)));
-		popToken(input, sax::Token::END_ELEMENT, "state");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "state");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "finalStates");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "finalStates");
 	return finalStates;
 }
 
 std::set<alphabet::Symbol> AutomatonFromXMLParser::parseStackAlphabet(std::list<sax::Token> &input) const {
 	std::set<alphabet::Symbol> stackSymbols;
-	popToken(input, sax::Token::START_ELEMENT, "stackAlphabet");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "stackAlphabet");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		stackSymbols.insert(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "stackAlphabet");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "stackAlphabet");
 	return stackSymbols;
 }
 
 std::set<alphabet::Symbol> AutomatonFromXMLParser::parseInitialSymbols(std::list<sax::Token> &input) const {
 	std::set<alphabet::Symbol> initialSymbols;
-	popToken(input, sax::Token::START_ELEMENT, "initialAlphabet");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "initialAlphabet");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		initialSymbols.insert(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "initialAlphabet");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "initialAlphabet");
 	return initialSymbols;
 }
 
 std::set<alphabet::Symbol> AutomatonFromXMLParser::parseTapeAlphabet(std::list<sax::Token> &input) const {
 	std::set<alphabet::Symbol> tapeSymbols;
-	popToken(input, sax::Token::START_ELEMENT, "tapeAlphabet");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "tapeAlphabet");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		tapeSymbols.insert(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "tapeAlphabet");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "tapeAlphabet");
 	return tapeSymbols;
 }
 
 alphabet::Symbol AutomatonFromXMLParser::parseBlankSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "blankSymbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "blankSymbol");
 	
 	alphabet::Symbol result = alphabet::Symbol(alphabet::BlankSymbol());
-	if (isToken(input, sax::Token::START_ELEMENT, "blank")) {
+	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "blank")) {
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT,"blank");
+		popToken(input, sax::Token::TokenType::END_ELEMENT,"blank");
 	} else {
 		result = alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input)))));
 	}
 
-	popToken(input, sax::Token::END_ELEMENT, "blankSymbol");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "blankSymbol");
 
 	return result;
 }
 
 template<class T>
 void AutomatonFromXMLParser::parseTransitions(std::list<sax::Token> &input, T& automaton) const {
-	popToken(input, sax::Token::START_ELEMENT, "transitions");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "transition");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "transitions");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
 		parseTransition(input, automaton);
-		popToken(input, sax::Token::END_ELEMENT, "transition");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "transitions");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "transitions");
 }
 
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, DFA& automaton) const {
@@ -270,23 +270,23 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Epsil
 void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, UnknownAutomaton& automaton) const {
 	UnknownTransition transition;
 
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		if (isToken(input, sax::Token::START_ELEMENT, "from")) {
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		if (isToken(input, sax::Token::TokenType::START_ELEMENT, "from")) {
 			transition.setFrom(parseTransitionFrom(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "input")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "input")) {
 			transition.setInput(parseTransitionInputBlankEpsilonSymbol(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "to")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "to")) {
 			transition.setTo(parseTransitionFrom(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "pop")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "pop")) {
 			transition.setPop(parseTransitionPop(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "push")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "push")) {
 			transition.setPush(parseTransitionPush(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "output")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "output")) {
 			transition.setOutput(parseTransitionOutputBlankEpsilonSymbol(input));
-		} else if (isToken(input, sax::Token::START_ELEMENT, "shift")) {
+		} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "shift")) {
 			transition.setShift(parseTransitionShift(input));
 		} else {
-			throw sax::ParserException(sax::Token("transitions", sax::Token::END_ELEMENT), input.front());
+			throw sax::ParserException(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT), input.front());
 		}
 	}
 
@@ -294,150 +294,150 @@ void AutomatonFromXMLParser::parseTransition(std::list<sax::Token>& input, Unkno
 }
 
 State AutomatonFromXMLParser::parseTransitionTo(std::list<sax::Token> &input) const {
-	popToken(input, sax::Token::START_ELEMENT, "to");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "to");
 	State state(parseLabel(input));
-	popToken(input, sax::Token::END_ELEMENT, "to");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "to");
 	return state;
 }
 
 State AutomatonFromXMLParser::parseTransitionFrom(std::list<sax::Token> &input) const {
-	popToken(input, sax::Token::START_ELEMENT, "from");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "from");
 	State state(parseLabel(input));
-	popToken(input, sax::Token::END_ELEMENT, "from");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "from");
 	return state;
 }
 
 Shift AutomatonFromXMLParser::parseTransitionShift(std::list<sax::Token>& input) const {
 	Shift shift;
 
-	popToken(input, sax::Token::START_ELEMENT, "shift");
-	if (isToken(input, sax::Token::CHARACTER, "left")) {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "shift");
+	if (isToken(input, sax::Token::TokenType::CHARACTER, "left")) {
 		shift = LEFT;
 		input.pop_front();
-	} else if (isToken(input, sax::Token::CHARACTER, "right")) {
+	} else if (isToken(input, sax::Token::TokenType::CHARACTER, "right")) {
 		shift = RIGHT;
 		input.pop_front();
-	} else if (isToken(input, sax::Token::CHARACTER, "none")) {
+	} else if (isToken(input, sax::Token::TokenType::CHARACTER, "none")) {
 		shift = NONE;
 		input.pop_front();
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::CHARACTER), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::CHARACTER), input.front());
 	}
-	popToken(input, sax::Token::END_ELEMENT, "shift");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "shift");
 
 	return shift;
 }
 
 std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPop(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> pops;
-	popToken(input, sax::Token::START_ELEMENT, "pop");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "pop");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		pops.push_back(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "pop");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "pop");
 	return pops;
 }
 
 std::vector<alphabet::Symbol> AutomatonFromXMLParser::parseTransitionPush(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> pushes;
-	popToken(input, sax::Token::START_ELEMENT, "push");
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
-		popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "push");
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 		pushes.push_back(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
-		popToken(input, sax::Token::END_ELEMENT, "symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	}
-	popToken(input, sax::Token::END_ELEMENT, "push");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "push");
 	return pushes;
 }
 
 alphabet::Symbol AutomatonFromXMLParser::parseTransitionOutputSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 	alphabet::Symbol result = alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input)))));
-	popToken(input, sax::Token::END_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 	return result;
 }
 
 alphabet::Symbol AutomatonFromXMLParser::parseTransitionInputSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	alphabet::Symbol result = alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input)))));
-	popToken(input, sax::Token::END_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	return result;
 }
 
 std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	
 	std::variant<string::Epsilon, alphabet::Symbol> result;
-	if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		result.set<string::Epsilon>(string::Epsilon());
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT, "epsilon");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
 	}
 	
-	popToken(input, sax::Token::END_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	
 	return result;
 }
 
 std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputEpsilonSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 	
 	std::variant<string::Epsilon, alphabet::Symbol> result;
-	if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		result.set<string::Epsilon>(string::Epsilon());
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT, "epsilon");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	} else {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
 	}
 	
-	popToken(input, sax::Token::END_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 	
 	return result;
 }
 
 std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionInputBlankEpsilonSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "input");
 	
 	std::variant<string::Epsilon, alphabet::Symbol> result;
-	if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		result.set<string::Epsilon>(string::Epsilon());
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT, "epsilon");
-	} else if (isToken(input, sax::Token::START_ELEMENT, "blank")) {
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "blank")) {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::BlankSymbol()));
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT,"blank");
+		popToken(input, sax::Token::TokenType::END_ELEMENT,"blank");
 	} else {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
 	}
 	
-	popToken(input, sax::Token::END_ELEMENT, "input");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "input");
 	
 	return result;
 }
 
 std::variant<string::Epsilon, alphabet::Symbol> AutomatonFromXMLParser::parseTransitionOutputBlankEpsilonSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "output");
 	
 	std::variant<string::Epsilon, alphabet::Symbol> result;
-	if(isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		result.set<string::Epsilon>(string::Epsilon());
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT, "epsilon");
-	} else if (isToken(input, sax::Token::START_ELEMENT, "blank")) {
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "blank")) {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::BlankSymbol()));
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT,"blank");
+		popToken(input, sax::Token::TokenType::END_ELEMENT,"blank");
 	} else {
 		result.set<alphabet::Symbol>(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(parseLabel(input))))));
 	}
 	
-	popToken(input, sax::Token::END_ELEMENT, "output");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "output");
 	
 	return result;
 }
diff --git a/alib2/src/automaton/AutomatonToXMLComposer.cpp b/alib2/src/automaton/AutomatonToXMLComposer.cpp
index 5fff45b7c9f078fdecd771b2e872dee2798d4be1..f171f3d772e1a9300fc7d059c458e06af7759c68 100644
--- a/alib2/src/automaton/AutomatonToXMLComposer.cpp
+++ b/alib2/src/automaton/AutomatonToXMLComposer.cpp
@@ -11,39 +11,39 @@
 namespace automaton {
 
 void AutomatonToXMLComposer::printStates(std::list<sax::Token>& out, const std::set<State>& states, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
 	for (auto& state : states) {
 		printState(out, state, "state");
 	}
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::set<alphabet::Symbol>& symbols, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
 	for (auto& symbol : symbols) {
 		printSymbol(out, symbol, "symbol");
 	}
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printSymbols(std::list<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
 	for (auto& symbol : symbols) {
 		printSymbol(out, symbol, "symbol");
 	}
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printShift(std::list<sax::Token>& out, const Shift shift, std::string tagName) const {
-	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));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(SHIFT_NAMES [shift], sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printTransitions(std::list<sax::Token>& out, const UnknownAutomaton& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for (auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("transition", sax::Token::TokenType::START_ELEMENT));
 
 		if (transition.hasFrom())
 			printState(out, transition.getFrom(), "from");
@@ -66,97 +66,97 @@ void AutomatonToXMLComposer::printTransitions(std::list<sax::Token>& out, const
 		if (transition.getShift() != Shift::NOT_SET)
 			printShift(out, transition.getShift(), "shift");
 
-		out.push_back(sax::Token("transition", sax::Token::END_ELEMENT));
+		out.push_back(sax::Token("transition", sax::Token::TokenType::END_ELEMENT));
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
 
 void AutomatonToXMLComposer::printTransitions(std::list<sax::Token>& out, const DFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(auto& transition : automaton.getTransitions()) {
-		out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("transition", sax::Token::TokenType::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("transition", sax::Token::TokenType::END_ELEMENT));
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printTransitions(std::list<sax::Token>& out, const NFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(auto& transition : automaton.getTransitions()) {
 		for(auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+			out.push_back(sax::Token("transition", sax::Token::TokenType::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("transition", sax::Token::TokenType::END_ELEMENT));
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printTransitions(std::list<sax::Token>& out, const EpsilonNFA& automaton) const {
-	out.push_back(sax::Token("transitions", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::START_ELEMENT));
 	for(auto& transition : automaton.getTransitions()) {
 		for(auto& targetState: transition.second) {
-			out.push_back(sax::Token("transition", sax::Token::START_ELEMENT));
+			out.push_back(sax::Token("transition", sax::Token::TokenType::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("transition", sax::Token::TokenType::END_ELEMENT));
 		}
 	}
 
-	out.push_back(sax::Token("transitions", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("transitions", sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printState(std::list<sax::Token>& out, const State& state, std::string tagName) const {
-	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));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(state.getName(), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
-	out.push_back(sax::Token((std::string) symbol, sax::Token::CHARACTER));
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token((std::string) symbol, sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printInput(std::list<sax::Token>& out, const std::variant<string::Epsilon, alphabet::Symbol>& symbol, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::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));
+		out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
+		out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
 	} else if(symbol.get<alphabet::Symbol>().getSymbol() == alphabet::BlankSymbol::BLANK) {
-		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
-		out.push_back(sax::Token("blank", sax::Token::END_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::TokenType::START_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::TokenType::END_ELEMENT));
 	} else {
-		out.push_back(sax::Token((std::string) symbol.get<alphabet::Symbol>(), sax::Token::CHARACTER));
+		out.push_back(sax::Token((std::string) symbol.get<alphabet::Symbol>(), sax::Token::TokenType::CHARACTER));
 	}
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 void AutomatonToXMLComposer::printSymbol(std::list<sax::Token>& out, const alphabet::Symbol& symbol, std::string tagName) const {
-	out.push_back(sax::Token(tagName, sax::Token::START_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::START_ELEMENT));
 	if(symbol.getSymbol() == alphabet::BlankSymbol::BLANK) {
-		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
-		out.push_back(sax::Token("blank", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::TokenType::START_ELEMENT));
+		out.push_back(sax::Token("blank", sax::Token::TokenType::START_ELEMENT));
 	} else {
-		out.push_back(sax::Token((std::string) symbol, sax::Token::CHARACTER));
+		out.push_back(sax::Token((std::string) symbol, sax::Token::TokenType::CHARACTER));
 	}
-	out.push_back(sax::Token(tagName, sax::Token::END_ELEMENT));
+	out.push_back(sax::Token(tagName, sax::Token::TokenType::END_ELEMENT));
 }
 
 std::list<sax::Token> AutomatonToXMLComposer::compose(const AutomatonBase& automaton) const {
@@ -167,7 +167,7 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const AutomatonBase& autom
 
 std::list<sax::Token> AutomatonToXMLComposer::compose(const UnknownAutomaton& automaton) const {
 	std::list<sax::Token> out;
-	out.push_back(sax::Token("automaton", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("automaton", sax::Token::TokenType::START_ELEMENT));
 	
 	if (automaton.getStates().size() > 0)
 		printStates(out, automaton.getStates(), "states");
@@ -196,13 +196,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const UnknownAutomaton& au
 	if (automaton.getTransitions().size() > 0)
 		printTransitions(out, automaton);
 
-	out.push_back(sax::Token("automaton", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("automaton", sax::Token::TokenType::END_ELEMENT));
 	return out;
 }
 
 std::list<sax::Token> AutomatonToXMLComposer::compose(const DFA& automaton) const {
 	std::list<sax::Token> out;
-	out.push_back(sax::Token("DFA", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("DFA", sax::Token::TokenType::START_ELEMENT));
 
 	printStates(out, automaton.getStates(), "states");
 	printSymbols(out, automaton.getInputAlphabet(), "inputAlphabet");
@@ -210,13 +210,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const DFA& automaton) cons
 	printStates(out, automaton.getFinalStates(), "finalStates");
 	printTransitions(out, automaton);
 
-	out.push_back(sax::Token("DFA", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("DFA", sax::Token::TokenType::END_ELEMENT));
 	return out;
 }
 
 std::list<sax::Token> AutomatonToXMLComposer::compose(const NFA& automaton) const {
 	std::list<sax::Token> out;
-	out.push_back(sax::Token("NFA", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("NFA", sax::Token::TokenType::START_ELEMENT));
 
 	printStates(out, automaton.getStates(), "states");
 	printSymbols(out, automaton.getInputAlphabet(), "inputAlphabet");
@@ -224,13 +224,13 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const NFA& automaton) cons
 	printStates(out, automaton.getFinalStates(), "finalStates");
 	printTransitions(out, automaton);
 
-	out.push_back(sax::Token("NFA", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("NFA", sax::Token::TokenType::END_ELEMENT));
 	return out;
 }
 
 std::list<sax::Token> AutomatonToXMLComposer::compose(const EpsilonNFA& automaton) const {
 	std::list<sax::Token> out;
-	out.push_back(sax::Token("EpsilonNFA", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("EpsilonNFA", sax::Token::TokenType::START_ELEMENT));
 
 	printStates(out, automaton.getStates(), "states");
 	printSymbols(out, automaton.getInputAlphabet(), "inputAlphabet");
@@ -238,7 +238,7 @@ std::list<sax::Token> AutomatonToXMLComposer::compose(const EpsilonNFA& automato
 	printStates(out, automaton.getFinalStates(), "finalStates");
 	printTransitions(out, automaton);
 
-	out.push_back(sax::Token("EpsilonNFA", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("EpsilonNFA", sax::Token::TokenType::END_ELEMENT));
 	return out;
 }
 
diff --git a/alib2/src/label/LabelFromXMLParser.cpp b/alib2/src/label/LabelFromXMLParser.cpp
index c696dae48cd778f565a34a300c4eff48eb5450b1..66b345c04035c47992ffa212961400e3d3d40ca6 100644
--- a/alib2/src/label/LabelFromXMLParser.cpp
+++ b/alib2/src/label/LabelFromXMLParser.cpp
@@ -15,23 +15,23 @@
 namespace label {
 
 Label LabelFromXMLParser::parse(std::list<sax::Token>& input) const {
-	if(isToken(input, sax::Token::START_ELEMENT, "IntegerLabel")) {
-		popToken(input, sax::Token::START_ELEMENT, "IntegerLabel");
-		label::Label data = Label(IntegerLabel(std::stoi(popTokenData(input, sax::Token::CHARACTER))));
-		popToken(input, sax::Token::END_ELEMENT, "IntegerLabel");
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "IntegerLabel")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "IntegerLabel");
+		label::Label data = Label(IntegerLabel(std::stoi(popTokenData(input, sax::Token::TokenType::CHARACTER))));
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "IntegerLabel");
 		return data;
-	} else if(isToken(input, sax::Token::START_ELEMENT, "StringLabel")) {
-		popToken(input, sax::Token::START_ELEMENT, "StringLabel");
-		label::Label data = Label(StringLabel(popTokenData(input, sax::Token::CHARACTER)));
-		popToken(input, sax::Token::END_ELEMENT, "StringLabel");
+	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "StringLabel")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "StringLabel");
+		label::Label data = Label(StringLabel(popTokenData(input, sax::Token::TokenType::CHARACTER)));
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "StringLabel");
 		return data;
-	} else if(isToken(input, sax::Token::START_ELEMENT, "CharacterLabel")) {
-		popToken(input, sax::Token::START_ELEMENT, "CharacterLabel");
-		label::Label data = Label(CharacterLabel(popTokenData(input, sax::Token::CHARACTER)[0]));
-		popToken(input, sax::Token::END_ELEMENT, "CharacterLabel");
+	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CharacterLabel")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "CharacterLabel");
+		label::Label data = Label(CharacterLabel(popTokenData(input, sax::Token::TokenType::CHARACTER)[0]));
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "CharacterLabel");
 		return data;
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::START_ELEMENT), input.front());
 	}
 }
 
diff --git a/alib2/src/label/LabelToXMLComposer.cpp b/alib2/src/label/LabelToXMLComposer.cpp
index 58d36b1456ba9f96f865483d1725702fe5d09baa..f87828ea666776ea42885cff65382dee11ddef06 100644
--- a/alib2/src/label/LabelToXMLComposer.cpp
+++ b/alib2/src/label/LabelToXMLComposer.cpp
@@ -16,25 +16,25 @@ namespace label {
 void LabelToXMLComposer::Visit(void* userData, const IntegerLabel& label) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("IntegerLabel", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token(std::itos(label.getData()), sax::Token::CHARACTER));
-	out.push_back(sax::Token("IntegerLabel", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("IntegerLabel", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(std::itos(label.getData()), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("IntegerLabel", sax::Token::TokenType::END_ELEMENT));
 }
 
 void LabelToXMLComposer::Visit(void* userData, const CharacterLabel& label) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("CharacterLabel", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token(std::string(1, label.getData()), sax::Token::CHARACTER));
-	out.push_back(sax::Token("CharacterLabel", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("CharacterLabel", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(std::string(1, label.getData()), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("CharacterLabel", sax::Token::TokenType::END_ELEMENT));
 }
 
 void LabelToXMLComposer::Visit(void* userData, const StringLabel& label) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("StringLabel", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token(label.getData(), sax::Token::CHARACTER));
-	out.push_back(sax::Token("StringLabel", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("StringLabel", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token(label.getData(), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("StringLabel", sax::Token::TokenType::END_ELEMENT));
 }
 
 void LabelToXMLComposer::Visit(void* userData, const Label& label) const {
diff --git a/alib2/src/regexp/RegExpFromXMLParser.cpp b/alib2/src/regexp/RegExpFromXMLParser.cpp
index 4630885b8e7cc9f970399234c543581175ec1e0b..9aa1028697e5ba1317c089da0cd76c90408ead0b 100644
--- a/alib2/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2/src/regexp/RegExpFromXMLParser.cpp
@@ -12,44 +12,44 @@
 namespace regexp {
 
 RegExp RegExpFromXMLParser::parse(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "regexp");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "regexp");
 	
 	RegExp regexp;
 	parseAlphabet(input, regexp);
 	
-	if(isTokenType(input, sax::Token::START_ELEMENT)) {
+	if(isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		RegExpElement* element = parseElement(input);
 		regexp.setRegExp(std::move(*element));
 		delete element;
 	}
 	
-	popToken(input, sax::Token::END_ELEMENT, "regexp");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "regexp");
 
 	return regexp;
 }
 
 void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, RegExp& regexp) const {
-	popToken(input, sax::Token::START_ELEMENT, "alphabet");
-	while (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
+	while (isToken(input, sax::Token::TokenType::START_ELEMENT, "symbol")) {
 		alphabet::Symbol* symbol = parseSymbol<alphabet::Symbol>(input);
 		regexp.addSymbolToAlphabet(*symbol);
 		delete symbol;
 	}
-	popToken(input, sax::Token::END_ELEMENT, "alphabet");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
 RegExpElement* RegExpFromXMLParser::parseElement(std::list<sax::Token>& input) const {
-	if (isToken(input, sax::Token::START_ELEMENT, "symbol")) {
+	if (isToken(input, sax::Token::TokenType::START_ELEMENT, "symbol")) {
 		return parseSymbol<RegExpSymbol>(input);
-	} else if (isToken(input, sax::Token::START_ELEMENT, "empty")) {
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "empty")) {
 		return parseEmpty(input);
-	} else if (isToken(input, sax::Token::START_ELEMENT, "epsilon")) {
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
 		return parseEpsilon(input);
-	} else if (isToken(input, sax::Token::START_ELEMENT, "iteration")) {
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "iteration")) {
 		return parseIteration(input);
-	} else if (isToken(input, sax::Token::START_ELEMENT, "alternation")) {
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "alternation")) {
 		return parseAlternation(input);
-	} else if (isToken(input, sax::Token::START_ELEMENT, "concatenation")) {
+	} else if (isToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation")) {
 		return parseConcatenation(input);
 	} else {
 		return NULL;
@@ -57,7 +57,7 @@ RegExpElement* RegExpFromXMLParser::parseElement(std::list<sax::Token>& input) c
 }
 
 Alternation* RegExpFromXMLParser::parseAlternation(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "alternation");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "alternation");
 
 	RegExpElement* element1 = parseElement(input);
 	if(!element1) throw alib::AlibException("Not enought elements in alternation");
@@ -68,18 +68,18 @@ Alternation* RegExpFromXMLParser::parseAlternation(std::list<sax::Token>& input)
 	delete element1;
 	delete element2;
 	
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		RegExpElement* element = parseElement(input);
 		alternation->appendElement(std::move(*element));
 		delete element;
 	}
 
-	popToken(input, sax::Token::END_ELEMENT, "alternation");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "alternation");
 	return alternation;
 }
 
 Concatenation* RegExpFromXMLParser::parseConcatenation(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "concatenation");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "concatenation");
 
 	RegExpElement* element1 = parseElement(input);
 	if(!element1) throw alib::AlibException("Not enought elements in concatenation");
@@ -90,53 +90,53 @@ Concatenation* RegExpFromXMLParser::parseConcatenation(std::list<sax::Token>& in
 	delete element1;
 	delete element2;
 	
-	while (isTokenType(input, sax::Token::START_ELEMENT)) {
+	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
 		RegExpElement* element = parseElement(input);
 		concatenation->appendElement(std::move(*element));
 		delete element;
 	}
 
-	popToken(input, sax::Token::END_ELEMENT, "concatenation");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "concatenation");
 	return concatenation;
 
 }
 
 Iteration* RegExpFromXMLParser::parseIteration(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "iteration");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "iteration");
 
 	RegExpElement* element = parseElement(input);
-	if(!element) throw sax::ParserException(sax::Token("", sax::Token::CHARACTER), input.front());
+	if(!element) throw sax::ParserException(sax::Token("", sax::Token::TokenType::CHARACTER), input.front());
 	Iteration* iteration = new Iteration(std::move(*element));
 	delete element;
 
-	popToken(input, sax::Token::END_ELEMENT, "iteration");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "iteration");
 	return iteration;
 }
 
 RegExpEpsilon* RegExpFromXMLParser::parseEpsilon(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "epsilon");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon");
 
 	RegExpEpsilon* epsilon = new RegExpEpsilon();
 
-	popToken(input, sax::Token::END_ELEMENT, "epsilon");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
 	return epsilon;
 }
 
 RegExpEmpty* RegExpFromXMLParser::parseEmpty(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "empty");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "empty");
 
 	RegExpEmpty* empty = new RegExpEmpty();
 
-	popToken(input, sax::Token::END_ELEMENT, "empty");
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "empty");
 	return empty;
 }
 
 template <class T>
 T* RegExpFromXMLParser::parseSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "symbol");
 
-	T* symbol = new T(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(popTokenData(input, sax::Token::CHARACTER))))));
-	popToken(input, sax::Token::END_ELEMENT, "symbol");
+	T* symbol = new T(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(popTokenData(input, sax::Token::TokenType::CHARACTER))))));
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "symbol");
 	return symbol;
 }
 
diff --git a/alib2/src/regexp/RegExpToXMLComposer.cpp b/alib2/src/regexp/RegExpToXMLComposer.cpp
index 3f5245d364e3ef58f7503be36e48156ca79b5860..965c5f20ddadb5956b49a942b0f9185a2d869574 100644
--- a/alib2/src/regexp/RegExpToXMLComposer.cpp
+++ b/alib2/src/regexp/RegExpToXMLComposer.cpp
@@ -12,18 +12,18 @@ namespace regexp {
 void RegExpToXMLComposer::Visit(void* userData, const RegExp& regexp) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("regexp", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("regexp", sax::Token::TokenType::START_ELEMENT));
 	{
-		out.push_back(sax::Token("alphabet", sax::Token::START_ELEMENT));
+		out.push_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
 		for (const auto& symbol: regexp.getAlphabet()) {
-			out.push_back(sax::Token("symbol", sax::Token::START_ELEMENT));
-			out.push_back(sax::Token((std::string) symbol, sax::Token::CHARACTER));
-			out.push_back(sax::Token("symbol", sax::Token::END_ELEMENT));
+			out.push_back(sax::Token("symbol", sax::Token::TokenType::START_ELEMENT));
+			out.push_back(sax::Token((std::string) symbol, sax::Token::TokenType::CHARACTER));
+			out.push_back(sax::Token("symbol", sax::Token::TokenType::END_ELEMENT));
 		}
-		out.push_back(sax::Token("alphabet", sax::Token::END_ELEMENT));
+		out.push_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
 	}
 	regexp.getRegExp().Accept(userData, *this);
-	out.push_back(sax::Token("regexp", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("regexp", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const RegExpElement::element_type& element) const {
@@ -33,55 +33,55 @@ void RegExpToXMLComposer::Visit(void* userData, const RegExpElement::element_typ
 void RegExpToXMLComposer::Visit(void* userData, const Alternation& alternation) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("alternation", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("alternation", sax::Token::TokenType::START_ELEMENT));
 	for (const auto& element : alternation.getElements()) {
 		const RegExpElement::element_type& object = static_cast<const RegExpElement::element_type&>(*element);
 		object.Accept(userData, *this);
 	}
-	out.push_back(sax::Token("alternation", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("alternation", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const Concatenation& concatenation) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("concatenation", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("concatenation", sax::Token::TokenType::START_ELEMENT));
 	for (auto element : concatenation.getElements()) {
 		const RegExpElement::element_type& object = static_cast<const RegExpElement::element_type&>(*element);
 		object.Accept(userData, *this);
 	}
-	out.push_back(sax::Token("concatenation", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("concatenation", sax::Token::TokenType::END_ELEMENT));
 
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const Iteration& iteration) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("iteration", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("iteration", sax::Token::TokenType::START_ELEMENT));
 	const RegExpElement::element_type& object = static_cast<const RegExpElement::element_type&>(iteration.getElement());
 	object.Accept(userData, *this);
-	out.push_back(sax::Token("iteration", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("iteration", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const RegExpSymbol& symbol) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("symbol", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token((std::string) symbol.getSymbol(), sax::Token::CHARACTER));
-	out.push_back(sax::Token("symbol", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("symbol", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token((std::string) symbol.getSymbol(), sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("symbol", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const RegExpEpsilon&) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("epsilon", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token("epsilon", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("epsilon", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token("epsilon", sax::Token::TokenType::END_ELEMENT));
 }
 
 void RegExpToXMLComposer::Visit(void* userData, const RegExpEmpty&) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("empty", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token("empty", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("empty", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token("empty", sax::Token::TokenType::END_ELEMENT));
 }
 
 std::list<sax::Token> RegExpToXMLComposer::compose(const RegExp& regexp) const {
diff --git a/alib2/src/sax/SaxComposeInterface.cpp b/alib2/src/sax/SaxComposeInterface.cpp
index b4b28594eb5a554741e1ad38a6023a0bb18ec775..86ad5ab0be48841a273ffcfd58c969a2bd9c695c 100644
--- a/alib2/src/sax/SaxComposeInterface.cpp
+++ b/alib2/src/sax/SaxComposeInterface.cpp
@@ -55,21 +55,21 @@ void SaxComposeInterface::xmlSAXUserPrint(xmlTextWriterPtr writer, const std::li
 	std::deque<Token> stack;
 	for(const Token& token : in) {
 	  switch(token.getType()) {
-		case Token::START_ELEMENT:
+		case Token::TokenType::START_ELEMENT:
 		  xmlTextWriterStartElement(writer, (const xmlChar*) token.getData().c_str());
 		  stack.push_back(token);
 		  break;
-		case Token::END_ELEMENT:
+		case Token::TokenType::END_ELEMENT:
 		  if(stack.empty() || stack.back().getData() != token.getData()) {
-			throw ComposerException(Token(stack.back().getData(), Token::END_ELEMENT), token);
+			throw ComposerException(Token(stack.back().getData(), Token::TokenType::END_ELEMENT), token);
 		  }
 		  stack.pop_back();
 		  xmlTextWriterEndElement(writer);
 		  break;
-		case Token::CHARACTER:
+		case Token::TokenType::CHARACTER:
 		  xmlTextWriterWriteString(writer, (const xmlChar*) token.getData().c_str());
 		  break;
-		case Token::ATTRIBUTE:
+		case Token::TokenType::ATTRIBUTE:
 		  //TODO
 		  break;
 	  }
diff --git a/alib2/src/sax/SaxParseInterface.cpp b/alib2/src/sax/SaxParseInterface.cpp
index 70dafea48605a78a7addf5fd22443cb16f30f8a5..91b2a22f478bbc2b9a841505383e8a635c0f3570 100644
--- a/alib2/src/sax/SaxParseInterface.cpp
+++ b/alib2/src/sax/SaxParseInterface.cpp
@@ -62,17 +62,17 @@ void SaxParseInterface::characters(void * userData, const xmlChar * ch, int len)
 	std::list<Token> &out = *((std::list<Token>*) userData);
 	std::string tmp((const char*) ch, len);
 
-	if(! std::all_of(tmp.begin(), tmp.end(), isspace)) out.push_back(Token(std::move(tmp), Token::CHARACTER));
+	if(! std::all_of(tmp.begin(), tmp.end(), isspace)) out.push_back(Token(std::move(tmp), Token::TokenType::CHARACTER));
 }
 
 void SaxParseInterface::startElement(void* userData, const xmlChar* name, const xmlChar** /*attrs*/) {
 	std::list<Token> &out = *((std::list<Token>*) userData);
-	out.push_back(Token((const char*) name, Token::START_ELEMENT));
+	out.push_back(Token((const char*) name, Token::TokenType::START_ELEMENT));
 }
 
 void SaxParseInterface::endElement(void * userData, const xmlChar * name) {
 	std::list<Token> &out = *((std::list<Token>*) userData);
-	out.push_back(Token((const  char*) name, Token::END_ELEMENT));
+	out.push_back(Token((const  char*) name, Token::TokenType::END_ELEMENT));
 }
 
 } /* namespace sax */
diff --git a/alib2/src/sax/Token.h b/alib2/src/sax/Token.h
index 6d117555e3ef80d1476622191c82be89f7ac1cfe..c2aab3522d72f61c1cf8b716e27b3847c193b7ab 100644
--- a/alib2/src/sax/Token.h
+++ b/alib2/src/sax/Token.h
@@ -19,7 +19,7 @@ namespace sax {
 class Token {
 public:
 
-	enum TokenType {
+	enum class TokenType {
 		START_ELEMENT, END_ELEMENT, ATTRIBUTE, CHARACTER
 	};
 
diff --git a/alib2/src/string/StringFromXMLParser.cpp b/alib2/src/string/StringFromXMLParser.cpp
index eea77b26d867e8d0164770633acd4d747a479b3d..5e824267547bd187f3c546d78a51164168fa642b 100644
--- a/alib2/src/string/StringFromXMLParser.cpp
+++ b/alib2/src/string/StringFromXMLParser.cpp
@@ -17,43 +17,43 @@
 namespace string {
 
 String StringFromXMLParser::parse(std::list<sax::Token>& input) const {
-	if(isToken(input, sax::Token::START_ELEMENT, "Epsilon")) {
-		popToken(input, sax::Token::START_ELEMENT, "Epsilon");
-		popToken(input, sax::Token::END_ELEMENT, "Epsilon");
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "Epsilon")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "Epsilon");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "Epsilon");
 		return String(Epsilon());
-	} else if(isToken(input, sax::Token::START_ELEMENT, "LinearString")) {
-		popToken(input, sax::Token::START_ELEMENT, "LinearString");
+	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LinearString")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "LinearString");
 		std::vector<alphabet::Symbol> data = parseContent(input);
-		popToken(input, sax::Token::END_ELEMENT, "LinearString");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "LinearString");
 		return String(LinearString(data));
-	} else if(isToken(input, sax::Token::START_ELEMENT, "CyclicString")) {
-		popToken(input, sax::Token::START_ELEMENT, "CyclicString");
+	} else if(isToken(input, sax::Token::TokenType::START_ELEMENT, "CyclicString")) {
+		popToken(input, sax::Token::TokenType::START_ELEMENT, "CyclicString");
 		std::vector<alphabet::Symbol> data = parseContent(input);
-		popToken(input, sax::Token::END_ELEMENT, "CyclicString");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "CyclicString");
 		return String(LinearString(data));
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::START_ELEMENT), input.front());
 	}
 }
 
 std::vector<alphabet::Symbol> StringFromXMLParser::parseContent(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> data;
-	while (isToken(input, sax::Token::START_ELEMENT, "Symbol")) {
+	while (isToken(input, sax::Token::TokenType::START_ELEMENT, "Symbol")) {
 		data.push_back(parseSymbol(input));
 	}
 	return data;
 }
 
 alphabet::Symbol StringFromXMLParser::parseSymbol(std::list<sax::Token>& input) const {
-	popToken(input, sax::Token::START_ELEMENT, "Symbol");
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "Symbol");
 
-	if (input.front().getType() == sax::Token::CHARACTER) {
+	if (input.front().getType() == sax::Token::TokenType::CHARACTER) {
 		alphabet::Symbol symbol = alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::StringLabel(input.front().getData()))));
 		input.pop_front();
-		popToken(input, sax::Token::END_ELEMENT, "Symbol");
+		popToken(input, sax::Token::TokenType::END_ELEMENT, "Symbol");
 		return symbol;
 	} else {
-		throw sax::ParserException(sax::Token("", sax::Token::CHARACTER), input.front());
+		throw sax::ParserException(sax::Token("", sax::Token::TokenType::CHARACTER), input.front());
 	}
 }
 
diff --git a/alib2/src/string/StringToXMLComposer.cpp b/alib2/src/string/StringToXMLComposer.cpp
index 480825fb05724657462090527e3051e31c17a6e1..87871557dadb80ce022a66853bea680feb7f12e9 100644
--- a/alib2/src/string/StringToXMLComposer.cpp
+++ b/alib2/src/string/StringToXMLComposer.cpp
@@ -15,36 +15,36 @@ namespace string {
 void StringToXMLComposer::Visit(void* userData, const alphabet::Symbol& symbol) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("symbol", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token((std::string) symbol, sax::Token::CHARACTER));
-	out.push_back(sax::Token("symbol", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("symbol", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token((std::string) symbol, sax::Token::TokenType::CHARACTER));
+	out.push_back(sax::Token("symbol", sax::Token::TokenType::END_ELEMENT));
 }
 
 void StringToXMLComposer::Visit(void* userData, const Epsilon&) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("Epsilon", sax::Token::START_ELEMENT));
-	out.push_back(sax::Token("Epsilon", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("Epsilon", sax::Token::TokenType::START_ELEMENT));
+	out.push_back(sax::Token("Epsilon", sax::Token::TokenType::END_ELEMENT));
 }
 
 void StringToXMLComposer::Visit(void* userData, const CyclicString& string) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("CyclicString", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("CyclicString", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& symbol : string.getContent()) {
 		Visit((void*) &out, symbol);
 	}
-	out.push_back(sax::Token("CyclicString", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("CyclicString", sax::Token::TokenType::END_ELEMENT));
 }
 
 void StringToXMLComposer::Visit(void* userData, const LinearString& string) const {
 	std::list<sax::Token> &out = *((std::list<sax::Token>*) userData);
 
-	out.push_back(sax::Token("LinearString", sax::Token::START_ELEMENT));
+	out.push_back(sax::Token("LinearString", sax::Token::TokenType::START_ELEMENT));
 	for(const auto& symbol : string.getContent()) {
 		Visit((void*) &out, symbol);
 	}
-	out.push_back(sax::Token("LinearString", sax::Token::END_ELEMENT));
+	out.push_back(sax::Token("LinearString", sax::Token::TokenType::END_ELEMENT));
 }
 
 void StringToXMLComposer::Visit(void* userData, const String& string) const {