diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
deleted file mode 100644
index e6aef492b0fe3f97622a17fcc7ed05b935f36d52..0000000000000000000000000000000000000000
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
+++ /dev/null
@@ -1,35 +0,0 @@
-/*
- * AutomatonFromXMLParser.cpp
- *
- *  Created on: Oct 12, 2013
- *      Author: Jan Travnicek
- */
-
-#include "AutomatonFromXMLParser.h"
-#include <sax/ParserException.h>
-#include "Shift.h"
-#include "../../regexp/RegExp.h"
-
-namespace automaton {
-
-Shift AutomatonFromXMLParser::parseTransitionShift ( std::deque < sax::Token >::iterator & input ) {
-	Shift shift;
-
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "shift" );
-
-	if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "left" ) )
-		shift = Shift::LEFT;
-	else if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "right" ) )
-		shift = Shift::RIGHT;
-	else if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "none" ) )
-		shift = Shift::NONE;
-	else
-		throw sax::ParserException ( sax::Token ( "", sax::Token::TokenType::CHARACTER ), * input );
-
-	++input;
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "shift" );
-
-	return shift;
-}
-
-} /* namespace automaton */
diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.h b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
index 7a85c96a0f54347c6d3ab921818e8f9b760aaf16..7db611b852e2136d766af77d950e2357c0b3e16d 100644
--- a/alib2data/src/automaton/common/AutomatonFromXMLParser.h
+++ b/alib2data/src/automaton/common/AutomatonFromXMLParser.h
@@ -8,15 +8,18 @@
 #ifndef AUTOMATON_FROM_XML_PARSER_H_
 #define AUTOMATON_FROM_XML_PARSER_H_
 
-#include <sax/FromXMLParserHelper.h>
 #include <set>
 #include <vector>
 #include <variant>
 #include <map>
-#include "Shift.h"
+
+#include <sax/FromXMLParserHelper.h>
+#include <sax/ParserException.h>
 #include <core/xmlApi.hpp>
+
 #include "../../regexp/unbounded/UnboundedRegExpStructure.h"
 #include <alphabet/RankedSymbol.h>
+#include "Shift.h"
 
 namespace automaton {
 
@@ -92,7 +95,26 @@ public:
 	template < class SymbolType >
 	static std::vector<SymbolType> parseTransitionOutputSymbolMultiple(std::deque<sax::Token>::iterator& input);
 
-	static Shift parseTransitionShift(std::deque<sax::Token>::iterator& input);
+	static Shift parseTransitionShift(std::deque<sax::Token>::iterator& input) {
+		Shift shift;
+
+		sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "shift" );
+
+		if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "left" ) )
+			shift = Shift::LEFT;
+		else if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "right" ) )
+			shift = Shift::RIGHT;
+		else if ( sax::FromXMLParserHelper::isToken ( input, sax::Token::TokenType::CHARACTER, "none" ) )
+			shift = Shift::NONE;
+		else
+			throw sax::ParserException ( sax::Token ( "", sax::Token::TokenType::CHARACTER ), * input );
+
+		++input;
+		sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "shift" );
+
+		return shift;
+	}
+
 	template < class SymbolType >
 	static regexp::UnboundedRegExpStructure < SymbolType > parseTransitionInputRegexp(std::deque<sax::Token>::iterator& input);
 };
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp b/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
deleted file mode 100644
index afdbf758e522cc949df1a32a5823a5f2855df5e0..0000000000000000000000000000000000000000
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * AutomatonToXMLComposer.cpp
- *
- *  Created on: Nov 11, 2013
- *      Author: Jan Travnicek
- */
-
-#include "AutomatonToXMLComposer.h"
-
-#include "Shift.h"
-#include "../../regexp/RegExp.h"
-
-namespace automaton {
-
-void AutomatonToXMLComposer::composeTransitionShift(std::deque<sax::Token>& out, Shift shift) {
-	out.emplace_back("shift", sax::Token::TokenType::START_ELEMENT);
-	out.emplace_back(SHIFT_NAMES [shiftToInt(shift)], sax::Token::TokenType::CHARACTER);
-	out.emplace_back("shift", sax::Token::TokenType::END_ELEMENT);
-}
-
-} /* namespace automaton */
-
diff --git a/alib2data/src/automaton/common/AutomatonToXMLComposer.h b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
index bce807c2b8b96d8fa6088edbdc66196caab6b241..b25d6685bf2b65f796d117b7c9c9950aa4768dcd 100644
--- a/alib2data/src/automaton/common/AutomatonToXMLComposer.h
+++ b/alib2data/src/automaton/common/AutomatonToXMLComposer.h
@@ -13,9 +13,11 @@
 #include <set>
 #include <variant>
 #include <map>
-#include "Shift.h"
+
 #include <sax/Token.h>
 #include <core/xmlApi.hpp>
+
+#include "Shift.h"
 #include "../../regexp/unbounded/UnboundedRegExpStructure.h"
 #include <alphabet/RankedSymbol.h>
 
@@ -91,7 +93,12 @@ public:
 	template < class SymbolType >
 	static void composeTransitionInputRegexp(std::deque<sax::Token>&, const regexp::UnboundedRegExpStructure < SymbolType > & regexp);
 
-	static void composeTransitionShift(std::deque<sax::Token>&, Shift shift);
+	static void composeTransitionShift(std::deque<sax::Token>& out, Shift shift) {
+		out.emplace_back("shift", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back(SHIFT_NAMES [shiftToInt(shift)], sax::Token::TokenType::CHARACTER);
+		out.emplace_back("shift", sax::Token::TokenType::END_ELEMENT);
+	}
+
 };
 
 template < class StateType >
diff --git a/alib2data/src/grammar/ContextFree/CFG.h b/alib2data/src/grammar/ContextFree/CFG.h
index f19a34859731af867cdf7f211cadbffb145e5450..90b583c9f7515bcf69fb36086c9797069b8869da 100644
--- a/alib2data/src/grammar/ContextFree/CFG.h
+++ b/alib2data/src/grammar/ContextFree/CFG.h
@@ -219,9 +219,9 @@ template < class SymbolType >
 CFG < SymbolType > CFG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, CFG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	CFG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -236,8 +236,8 @@ CFG < SymbolType > CFG < SymbolType >::parse ( std::deque < sax::Token >::iterat
 
 template < class SymbolType >
 void CFG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, CFG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextFree/CNF.h b/alib2data/src/grammar/ContextFree/CNF.h
index 6e3612ded7a5b7b0f1057b84df012eee712c9f0c..bb27ac72bf022349ac64680fd3e72a6fd909f40a 100644
--- a/alib2data/src/grammar/ContextFree/CNF.h
+++ b/alib2data/src/grammar/ContextFree/CNF.h
@@ -304,9 +304,9 @@ template < class SymbolType >
 CNF < SymbolType > CNF < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, CNF::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	CNF < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -324,8 +324,8 @@ CNF < SymbolType > CNF < SymbolType >::parse ( std::deque < sax::Token >::iterat
 
 template < class SymbolType >
 void CNF < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, CNF & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
index c3e4bff62538d4a7bfdef6995a9c4f6037728307..d4c39abbc7f10e6767f7a8738a32077cf3a67428 100644
--- a/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
+++ b/alib2data/src/grammar/ContextFree/EpsilonFreeCFG.h
@@ -242,9 +242,9 @@ template < class SymbolType >
 EpsilonFreeCFG < SymbolType > EpsilonFreeCFG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, EpsilonFreeCFG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	EpsilonFreeCFG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -262,8 +262,8 @@ EpsilonFreeCFG < SymbolType > EpsilonFreeCFG < SymbolType >::parse ( std::deque
 
 template < class SymbolType >
 void EpsilonFreeCFG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, EpsilonFreeCFG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextFree/GNF.h b/alib2data/src/grammar/ContextFree/GNF.h
index 3c98dfc4dde88cdaa26926856f2afbba129fe270..f9c024c46a1ec413fe8ce73f908a2a4acbc05253 100644
--- a/alib2data/src/grammar/ContextFree/GNF.h
+++ b/alib2data/src/grammar/ContextFree/GNF.h
@@ -251,9 +251,9 @@ template < class SymbolType >
 GNF < SymbolType > GNF < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, GNF::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	GNF < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -271,8 +271,8 @@ GNF < SymbolType > GNF < SymbolType >::parse ( std::deque < sax::Token >::iterat
 
 template < class SymbolType >
 void GNF < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, GNF & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::pair < SymbolType, std::vector < SymbolType > > rhs = GrammarFromXMLParser::parseRuleGNFRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::pair < SymbolType, std::vector < SymbolType > > rhs = GrammarFromXMLParser::parseRuleGNFRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextFree/LG.h b/alib2data/src/grammar/ContextFree/LG.h
index 80e172649cd9f516fd79181080ec76c1c810ea6f..37fbd2632dcd413294a036666fd15777ba4b440c 100644
--- a/alib2data/src/grammar/ContextFree/LG.h
+++ b/alib2data/src/grammar/ContextFree/LG.h
@@ -285,9 +285,9 @@ template < class SymbolType >
 LG < SymbolType > LG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	LG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -302,8 +302,8 @@ LG < SymbolType > LG < SymbolType >::parse ( std::deque < sax::Token >::iterator
 
 template < class SymbolType >
 void LG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextSensitive/CSG.h b/alib2data/src/grammar/ContextSensitive/CSG.h
index eb75e88bf3a08b618bff61d991cfc8d776d076e7..1a47c6eb20b9ded1928dea9772e967999e7306d3 100644
--- a/alib2data/src/grammar/ContextSensitive/CSG.h
+++ b/alib2data/src/grammar/ContextSensitive/CSG.h
@@ -209,9 +209,9 @@ template < class SymbolType >
 CSG < SymbolType > CSG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, CSG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	CSG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -229,10 +229,10 @@ CSG < SymbolType > CSG < SymbolType >::parse ( std::deque < sax::Token >::iterat
 
 template < class SymbolType >
 void CSG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, CSG & grammar ) {
-	std::vector < SymbolType > lContext = GrammarFromXMLParser::parseRuleLContext ( input );
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rContext = GrammarFromXMLParser::parseRuleRContext ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	std::vector < SymbolType > lContext = GrammarFromXMLParser::parseRuleLContext < SymbolType > ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rContext = GrammarFromXMLParser::parseRuleRContext < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lContext ), std::move ( lhs ), std::move ( rContext ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
index 1e8c1496330e95ef584560e657c2ce14a6a2752a..074b71b2c3f71847e59435943b1224afaeab4a1f 100644
--- a/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
+++ b/alib2data/src/grammar/ContextSensitive/NonContractingGrammar.h
@@ -207,9 +207,9 @@ template < class SymbolType >
 NonContractingGrammar < SymbolType > NonContractingGrammar < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, NonContractingGrammar::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	NonContractingGrammar < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -227,8 +227,8 @@ NonContractingGrammar < SymbolType > NonContractingGrammar < SymbolType >::parse
 
 template < class SymbolType >
 void NonContractingGrammar < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, NonContractingGrammar & grammar ) {
-	std::vector < SymbolType > lhs = GrammarFromXMLParser::parseRuleLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	std::vector < SymbolType > lhs = GrammarFromXMLParser::parseRuleLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Regular/LeftLG.h b/alib2data/src/grammar/Regular/LeftLG.h
index 54c0282bd7d3940c89839cd020ac018af6faadc8..5f5655f23e5833913d75ccb98cf0c4b5e912c591 100644
--- a/alib2data/src/grammar/Regular/LeftLG.h
+++ b/alib2data/src/grammar/Regular/LeftLG.h
@@ -271,9 +271,9 @@ template < class SymbolType >
 LeftLG < SymbolType > LeftLG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LeftLG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	LeftLG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -288,8 +288,8 @@ LeftLG < SymbolType > LeftLG < SymbolType >::parse ( std::deque < sax::Token >::
 
 template < class SymbolType >
 void LeftLG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LeftLG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Regular/LeftRG.h b/alib2data/src/grammar/Regular/LeftRG.h
index 72b4d1ec8f688142d3800d87712a0e0c1e5014e9..bd48006b08bd0ea30127187a267b0b22290cb084 100644
--- a/alib2data/src/grammar/Regular/LeftRG.h
+++ b/alib2data/src/grammar/Regular/LeftRG.h
@@ -374,9 +374,9 @@ template < class SymbolType >
 LeftRG < SymbolType > LeftRG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, LeftRG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	LeftRG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -394,8 +394,8 @@ LeftRG < SymbolType > LeftRG < SymbolType >::parse ( std::deque < sax::Token >::
 
 template < class SymbolType >
 void LeftRG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, LeftRG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Regular/RightLG.h b/alib2data/src/grammar/Regular/RightLG.h
index c3a96ea097a745983048a80ce70992ee54e15b24..e011f4ab65157e1d9e577b44d5cb501f9f9b6719 100644
--- a/alib2data/src/grammar/Regular/RightLG.h
+++ b/alib2data/src/grammar/Regular/RightLG.h
@@ -271,9 +271,9 @@ template < class SymbolType >
 RightLG < SymbolType > RightLG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, RightLG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	RightLG < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -288,8 +288,8 @@ RightLG < SymbolType > RightLG < SymbolType >::parse ( std::deque < sax::Token >
 
 template < class SymbolType >
 void RightLG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, RightLG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRawRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Regular/RightRG.h b/alib2data/src/grammar/Regular/RightRG.h
index c507c7eff3bd00f5f822440d2d652d1bcd7c9a13..947d092668d47febe2d787e191909912e239d661 100644
--- a/alib2data/src/grammar/Regular/RightRG.h
+++ b/alib2data/src/grammar/Regular/RightRG.h
@@ -317,9 +317,9 @@ template < class SymbolType >
 RightRG < SymbolType > RightRG < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, RightRG::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	RightRG < SymbolType > grammar ( std::move ( nonterminalAlphabet ), std::move ( terminalAlphabet ), std::move ( initialSymbol ) );
 
@@ -335,8 +335,8 @@ RightRG < SymbolType > RightRG < SymbolType >::parse ( std::deque < sax::Token >
 
 template < class SymbolType >
 void RightRG < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, RightRG & grammar ) {
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::variant < SymbolType, std::pair < SymbolType, SymbolType > > rhs = GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
index cbb9e1379933e9c790a13b5c0d0bf277ede2bce0..730b37603d41300053cfcfad2bef777abc65f4ea 100644
--- a/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h
@@ -188,9 +188,9 @@ template < class SymbolType >
 ContextPreservingUnrestrictedGrammar < SymbolType > ContextPreservingUnrestrictedGrammar < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ContextPreservingUnrestrictedGrammar::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	ContextPreservingUnrestrictedGrammar < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -205,10 +205,10 @@ ContextPreservingUnrestrictedGrammar < SymbolType > ContextPreservingUnrestricte
 
 template < class SymbolType >
 void ContextPreservingUnrestrictedGrammar < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, ContextPreservingUnrestrictedGrammar & grammar ) {
-	std::vector < SymbolType > lContext = GrammarFromXMLParser::parseRuleLContext ( input );
-	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS ( input );
-	std::vector < SymbolType > rContext = GrammarFromXMLParser::parseRuleRContext ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	std::vector < SymbolType > lContext = GrammarFromXMLParser::parseRuleLContext < SymbolType > ( input );
+	SymbolType lhs = GrammarFromXMLParser::parseRuleSingleSymbolLHS < SymbolType > ( input );
+	std::vector < SymbolType > rContext = GrammarFromXMLParser::parseRuleRContext < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lContext ), std::move ( lhs ), std::move ( rContext ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
index ce6bda2ea02e6085f0c57b70be98dfb23678754d..13c1d41f7116e3b5434f6ea9a99365bb2a16a40a 100644
--- a/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
+++ b/alib2data/src/grammar/Unrestricted/UnrestrictedGrammar.h
@@ -186,9 +186,9 @@ template < class SymbolType >
 UnrestrictedGrammar < SymbolType > UnrestrictedGrammar < SymbolType >::parse ( std::deque < sax::Token >::iterator & input ) {
 	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, UnrestrictedGrammar::getXmlTagName() );
 
-	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet ( input );
-	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet ( input );
-	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol ( input );
+	std::set < SymbolType > nonterminalAlphabet = GrammarFromXMLParser::parseNonterminalAlphabet < SymbolType > ( input );
+	std::set < SymbolType > terminalAlphabet = GrammarFromXMLParser::parseTerminalAlphabet < SymbolType > ( input );
+	SymbolType initialSymbol = GrammarFromXMLParser::parseInitialSymbol < SymbolType > ( input );
 
 	UnrestrictedGrammar < SymbolType > grammar ( std::move ( initialSymbol ) );
 
@@ -203,8 +203,8 @@ UnrestrictedGrammar < SymbolType > UnrestrictedGrammar < SymbolType >::parse ( s
 
 template < class SymbolType >
 void UnrestrictedGrammar < SymbolType >::parseRule ( std::deque < sax::Token >::iterator & input, UnrestrictedGrammar & grammar ) {
-	std::vector < SymbolType > lhs = GrammarFromXMLParser::parseRuleLHS ( input );
-	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS ( input );
+	std::vector < SymbolType > lhs = GrammarFromXMLParser::parseRuleLHS < SymbolType > ( input );
+	std::vector < SymbolType > rhs = GrammarFromXMLParser::parseRuleRHS < SymbolType > ( input );
 
 	grammar.addRule ( std::move ( lhs ), std::move ( rhs ) );
 }
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.cpp b/alib2data/src/grammar/common/GrammarFromXMLParser.cpp
deleted file mode 100644
index 1a5364f516ae1a1bf0875f3bdae9dc7f9b5f8689..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/common/GrammarFromXMLParser.cpp
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * GrammarFromXMLParser.cpp
- *
- *  Created on: Oct 12, 2013
- *      Author: Jan Travnicek
- */
-
-#include "GrammarFromXMLParser.h"
-#include <core/xmlApi.hpp>
-#include <sax/ParserException.h>
-#include "../../alphabet/Symbol.h"
-
-namespace grammar {
-
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) {
-	std::set<alphabet::Symbol> inputSymbols;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
-	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "nonterminalAlphabet");
-	return inputSymbols;
-}
-
-std::set<alphabet::Symbol> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) {
-	std::set<alphabet::Symbol> inputSymbols;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
-	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		inputSymbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "terminalAlphabet");
-	return inputSymbols;
-}
-
-alphabet::Symbol GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
-	alphabet::Symbol blank(alib::xmlApi<alphabet::Symbol>::parse(input));
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
-	return blank;
-}
-
-bool GrammarFromXMLParser::parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) {
-	bool generatesEpsilon;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
-	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
-		++input;
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "true");
-		generatesEpsilon = true;
-	} else {
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "false");
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "false");
-		generatesEpsilon = false;
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "generatesEpsilon");
-	return generatesEpsilon;
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>::iterator& input) {
-	std::vector<alphabet::Symbol> lContext;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
-	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		lContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lContext");
-	return lContext;
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>::iterator& input) {
-	std::vector<alphabet::Symbol> lhs;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
-	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		lhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
-	return lhs;
-}
-
-alphabet::Symbol GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
-	alphabet::Symbol lhs = alib::xmlApi<alphabet::Symbol>::parse(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
-	return lhs;
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>::iterator& input) {
-	std::vector<alphabet::Symbol> rContext;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
-	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		rContext.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rContext");
-	return rContext;
-}
-
-std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
-	std::vector<alphabet::Symbol> second;
-	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		second.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-	return std::make_pair(std::move(first), std::move(second));
-}
-
-std::vector<alphabet::Symbol> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>::iterator& input) {
-	std::vector<alphabet::Symbol> rhs;
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
-		++input;
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
-	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		rhs.push_back(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-	return rhs;
-}
-
-std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
-	alphabet::Symbol first = alib::xmlApi<alphabet::Symbol>::parse(input);
-	if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		alphabet::Symbol second = alib::xmlApi<alphabet::Symbol>::parse(input);
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::make_pair(std::move(first), std::move(second)));
-	} else {
-		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
-		return std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>(std::move(first));
-	}
-}
-
-} /* namespace grammar */
-
diff --git a/alib2data/src/grammar/common/GrammarFromXMLParser.h b/alib2data/src/grammar/common/GrammarFromXMLParser.h
index 08e4bcad851b7b566a542bd3f4cc8ccc389605b0..2be79243150633948881fadae71ad98fdf8cdac2 100644
--- a/alib2data/src/grammar/common/GrammarFromXMLParser.h
+++ b/alib2data/src/grammar/common/GrammarFromXMLParser.h
@@ -12,7 +12,9 @@
 #include <set>
 #include <variant>
 #include <vector>
-#include "../../alphabet/SymbolFeatures.h"
+
+#include <core/xmlApi.hpp>
+#include <sax/ParserException.h>
 #include <sax/FromXMLParserHelper.h>
 
 namespace grammar {
@@ -22,23 +24,168 @@ namespace grammar {
  */
 class GrammarFromXMLParser {
 public:
-	static std::set<alphabet::Symbol> parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input);
-	static std::set<alphabet::Symbol> parseTerminalAlphabet(std::deque<sax::Token>::iterator& input);
-	static alphabet::Symbol parseInitialSymbol(std::deque<sax::Token>::iterator& input);
-	static bool parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input);
-
-	static std::vector<alphabet::Symbol> parseRuleLContext(std::deque<sax::Token>::iterator& input);
-	static std::vector<alphabet::Symbol> parseRuleLHS(std::deque<sax::Token>::iterator& input);
-	static std::vector<alphabet::Symbol> parseRuleRContext(std::deque<sax::Token>::iterator& input);
-	static alphabet::Symbol parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input);
-	static std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>> parseRuleGNFRHS(std::deque<sax::Token>::iterator& input);
-	static std::vector<alphabet::Symbol> parseRuleRHS(std::deque<sax::Token>::iterator& input);
-	static std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::set<SymbolType> parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::set<SymbolType> parseTerminalAlphabet(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static SymbolType parseInitialSymbol(std::deque<sax::Token>::iterator& input);
+
+	static bool parseGeneratesEpsilon(std::deque<sax::Token>::iterator& input) {
+		bool generatesEpsilon;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "generatesEpsilon");
+		if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "true")) {
+			++input;
+			sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "true");
+			generatesEpsilon = true;
+		} else {
+			sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "false");
+			sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "false");
+			generatesEpsilon = false;
+		}
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "generatesEpsilon");
+		return generatesEpsilon;
+	}
+
+	template < class SymbolType >
+	static std::vector<SymbolType> parseRuleLContext(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::vector<SymbolType> parseRuleLHS(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::vector<SymbolType> parseRuleRContext(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static SymbolType parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::pair<SymbolType, std::vector<SymbolType>> parseRuleGNFRHS(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::vector<SymbolType> parseRuleRHS(std::deque<sax::Token>::iterator& input);
+	template < class SymbolType >
+	static std::variant<SymbolType, std::pair<SymbolType, SymbolType>> parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input);
 
 	template<class T>
 	static void parseRules(std::deque<sax::Token>::iterator& input, T& grammar);
 };
 
+template < class SymbolType >
+std::set<SymbolType> GrammarFromXMLParser::parseNonterminalAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<SymbolType> inputSymbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "nonterminalAlphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		inputSymbols.insert(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "nonterminalAlphabet");
+	return inputSymbols;
+}
+
+template < class SymbolType >
+std::set<SymbolType> GrammarFromXMLParser::parseTerminalAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<SymbolType> inputSymbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "terminalAlphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		inputSymbols.insert(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "terminalAlphabet");
+	return inputSymbols;
+}
+
+template < class SymbolType >
+SymbolType GrammarFromXMLParser::parseInitialSymbol(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "initialSymbol");
+	SymbolType blank(alib::xmlApi<SymbolType>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "initialSymbol");
+	return blank;
+}
+
+template < class SymbolType >
+std::vector<SymbolType> GrammarFromXMLParser::parseRuleLContext(std::deque<sax::Token>::iterator& input) {
+	std::vector<SymbolType> lContext;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lContext");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		lContext.push_back(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lContext");
+	return lContext;
+}
+
+template < class SymbolType >
+std::vector<SymbolType> GrammarFromXMLParser::parseRuleLHS(std::deque<sax::Token>::iterator& input) {
+	std::vector<SymbolType> lhs;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		lhs.push_back(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
+	return lhs;
+}
+
+template < class SymbolType >
+SymbolType GrammarFromXMLParser::parseRuleSingleSymbolLHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "lhs");
+	SymbolType lhs = alib::xmlApi<SymbolType>::parse(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "lhs");
+	return lhs;
+}
+
+template < class SymbolType >
+std::vector<SymbolType> GrammarFromXMLParser::parseRuleRContext(std::deque<sax::Token>::iterator& input) {
+	std::vector<SymbolType> rContext;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rContext");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		rContext.push_back(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rContext");
+	return rContext;
+}
+
+template < class SymbolType >
+std::pair<SymbolType, std::vector<SymbolType>> GrammarFromXMLParser::parseRuleGNFRHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	SymbolType first = alib::xmlApi<SymbolType>::parse(input);
+	std::vector<SymbolType> second;
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		second.push_back(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+	return std::make_pair(std::move(first), std::move(second));
+}
+
+template < class SymbolType >
+std::vector<SymbolType> GrammarFromXMLParser::parseRuleRHS(std::deque<sax::Token>::iterator& input) {
+	std::vector<SymbolType> rhs;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	if(sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, "epsilon")) {
+		++input;
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "epsilon");
+	} else while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		rhs.push_back(alib::xmlApi<SymbolType>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+	return rhs;
+}
+
+template < class SymbolType >
+std::variant<SymbolType, std::pair<SymbolType, SymbolType>> GrammarFromXMLParser::parseRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rhs");
+	SymbolType first = alib::xmlApi<SymbolType>::parse(input);
+	if(sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		SymbolType second = alib::xmlApi<SymbolType>::parse(input);
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+		return std::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::make_pair(std::move(first), std::move(second)));
+	} else {
+		sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rhs");
+		return std::variant<SymbolType, std::pair<SymbolType, SymbolType>>(std::move(first));
+	}
+}
+
 template<class T>
 void GrammarFromXMLParser::parseRules(std::deque<sax::Token>::iterator& input, T& grammar) {
 	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rules");
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.cpp b/alib2data/src/grammar/common/GrammarToXMLComposer.cpp
deleted file mode 100644
index ec867ec727a09c41898fca010d4e33c888feecbd..0000000000000000000000000000000000000000
--- a/alib2data/src/grammar/common/GrammarToXMLComposer.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * GrammarToXMLComposer.cpp
- *
- *  Created on: Nov 11, 2013
- *      Author: Jan Travnicek
- */
-
-#include "GrammarToXMLComposer.h"
-
-#include <core/xmlApi.hpp>
-#include "../../alphabet/Symbol.h"
-
-namespace grammar {
-
-void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) {
-	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) {
-	out.emplace_back("terminalAlphabet", sax::Token::TokenType::START_ELEMENT);
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("terminalAlphabet", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
-	out.emplace_back("initialSymbol", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back("initialSymbol", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) {
-	out.emplace_back("generatesEpsilon", sax::Token::TokenType::START_ELEMENT);
-	if(generatesEpsilon) {
-		out.emplace_back("true", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("true", sax::Token::TokenType::END_ELEMENT);
-	} else {
-		out.emplace_back("false", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("false", sax::Token::TokenType::END_ELEMENT);
-	}
-	out.emplace_back("generatesEpsilon", sax::Token::TokenType::END_ELEMENT);
-}
-
-
-void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
-	out.emplace_back("lContext", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("lContext", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
-	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
-	out.emplace_back("rContext", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("rContext", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
-	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.size() == 0) {
-		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-	} else for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<alphabet::Symbol>()) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbols.get<alphabet::Symbol>());
-	} else {
-		const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = symbols.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbols.first);
-
-	for (const auto& symbol : symbols.second) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	} else {
-		const std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>();
-		for (const auto& symbol : std::get<0>(rhs)) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-		alib::xmlApi<alphabet::Symbol>::compose(out, std::get<1>(rhs));
-		for (const auto& symbol : std::get<2>(rhs)) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	} else {
-		const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& rhs = symbols.get<std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>();
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.first);
-		for (const auto& symbol : rhs.second) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols) {
-	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
-	if(symbols.is<std::vector<alphabet::Symbol>>()) {
-		const std::vector<alphabet::Symbol>& rhs = symbols.get<std::vector<alphabet::Symbol>>();
-		if(rhs.size() == 0) {
-			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
-			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
-		} else {
-			for (const auto& symbol : symbols.get<std::vector<alphabet::Symbol>>()) {
-				alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-			}
-		}
-	} else {
-		const std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>& rhs = symbols.get<std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>();
-		for (const auto& symbol : rhs.first) {
-			alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-		}
-		alib::xmlApi<alphabet::Symbol>::compose(out, rhs.second);
-	}
-	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
-}
-
-} /* namespace grammar */
-
diff --git a/alib2data/src/grammar/common/GrammarToXMLComposer.h b/alib2data/src/grammar/common/GrammarToXMLComposer.h
index 642a7dba4995f9d56b4ad56f2d4b50b511539e07..2b5f14830af8b44a69eebdee091312ce016c18b0 100644
--- a/alib2data/src/grammar/common/GrammarToXMLComposer.h
+++ b/alib2data/src/grammar/common/GrammarToXMLComposer.h
@@ -13,8 +13,9 @@
 #include <tuple>
 #include <set>
 #include <variant>
-#include "../../alphabet/SymbolFeatures.h"
+
 #include <sax/Token.h>
+#include <core/xmlApi.hpp>
 
 namespace grammar {
 
@@ -23,23 +24,221 @@ namespace grammar {
  */
 class GrammarToXMLComposer {
 public:
-	static void composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
-	static void composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
-	static void composeInitialSymbol(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
-	static void composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon);
-
-	static void composeRuleLContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
-	static void composeRuleLHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
-	static void composeRuleRContext(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
-	static void composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
-	static void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& symbols);
-	static void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<alphabet::Symbol, std::pair<alphabet::Symbol, alphabet::Symbol>>& symbols);
-	static void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>& symbols);
-	static void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols);
-	static void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::pair<std::vector<alphabet::Symbol>, alphabet::Symbol>>& symbols);
-	static void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<alphabet::Symbol>, std::tuple<std::vector<alphabet::Symbol>, alphabet::Symbol, std::vector<alphabet::Symbol>>>& symbols);
+	template < class SymbolType >
+	static void composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeInitialSymbol(std::deque<sax::Token>& out, const SymbolType& symbol);
+
+	static void composeGeneratesEpsilon(std::deque<sax::Token>& out, bool generatesEpsilon) {
+		out.emplace_back("generatesEpsilon", sax::Token::TokenType::START_ELEMENT);
+		if(generatesEpsilon) {
+			out.emplace_back("true", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("true", sax::Token::TokenType::END_ELEMENT);
+		} else {
+			out.emplace_back("false", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("false", sax::Token::TokenType::END_ELEMENT);
+		}
+		out.emplace_back("generatesEpsilon", sax::Token::TokenType::END_ELEMENT);
+	}
+
+	template < class SymbolType >
+	static void composeRuleLContext(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeRuleLHS(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeRuleRContext(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const SymbolType& symbol);
+	template < class SymbolType >
+	static void composeRuleRHS(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols);
+	template < class SymbolType >
+	static void composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols);
+	template < class SymbolType >
+	static void composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<SymbolType, std::vector<SymbolType>>& symbols);
+	template < class SymbolType >
+	static void composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols);
+	template < class SymbolType >
+	static void composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols);
+	template < class SymbolType >
+	static void composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols);
 };
 
+template < class SymbolType >
+void GrammarToXMLComposer::composeNonterminalAlphabet(std::deque<sax::Token>& out, const std::set<SymbolType>& symbols) {
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("nonterminalAlphabet", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeTerminalAlphabet(std::deque<sax::Token>& out, const std::set<SymbolType>& symbols) {
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::START_ELEMENT);
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("terminalAlphabet", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeInitialSymbol(std::deque<sax::Token>& out, const SymbolType& symbol) {
+	out.emplace_back("initialSymbol", sax::Token::TokenType::START_ELEMENT);
+	alib::xmlApi<SymbolType>::compose(out, symbol);
+	out.emplace_back("initialSymbol", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleLContext(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols) {
+	out.emplace_back("lContext", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("lContext", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleLHS(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols) {
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleRContext(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols) {
+	out.emplace_back("rContext", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("rContext", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleSingleSymbolLHS(std::deque<sax::Token>& out, const SymbolType& symbol) {
+	out.emplace_back("lhs", sax::Token::TokenType::START_ELEMENT);
+	alib::xmlApi<SymbolType>::compose(out, symbol);
+	out.emplace_back("lhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleRHS(std::deque<sax::Token>& out, const std::vector<SymbolType>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.size() == 0) {
+		out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+		out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+	} else for (const auto& symbol : symbols) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleOneOrTwoSymbolsRHS(std::deque<sax::Token>& out, const std::variant<SymbolType, std::pair<SymbolType, SymbolType>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.template is<SymbolType>()) {
+		alib::xmlApi<SymbolType>::compose(out, symbols.template get<SymbolType>());
+	} else {
+		const std::pair<SymbolType, SymbolType>& rhs = symbols.template get<std::pair<SymbolType, SymbolType>>();
+		alib::xmlApi<SymbolType>::compose(out, rhs.first);
+		alib::xmlApi<SymbolType>::compose(out, rhs.second);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleGNFRHS(std::deque<sax::Token>& out, const std::pair<SymbolType, std::vector<SymbolType>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+
+	alib::xmlApi<SymbolType>::compose(out, symbols.first);
+
+	for (const auto& symbol : symbols.second) {
+		alib::xmlApi<SymbolType>::compose(out, symbol);
+	}
+
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.template is<std::vector<SymbolType>>()) {
+		const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else for (const auto& symbol : symbols.template get<std::vector<SymbolType>>()) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+	} else {
+		const std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>& rhs = symbols.template get<std::tuple<std::vector<SymbolType>, SymbolType, std::vector<SymbolType>>>();
+		for (const auto& symbol : std::get<0>(rhs)) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+		alib::xmlApi<SymbolType>::compose(out, std::get<1>(rhs));
+		for (const auto& symbol : std::get<2>(rhs)) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleLeftLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<SymbolType, std::vector<SymbolType>>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.template is<std::vector<SymbolType>>()) {
+		const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else for (const auto& symbol : symbols.template get<std::vector<SymbolType>>()) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+	} else {
+		const std::pair<SymbolType, std::vector<SymbolType>>& rhs = symbols.template get<std::pair<SymbolType, std::vector<SymbolType>>>();
+		alib::xmlApi<SymbolType>::compose(out, rhs.first);
+		for (const auto& symbol : rhs.second) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
+template < class SymbolType >
+void GrammarToXMLComposer::composeRuleRightLGRHS(std::deque<sax::Token>& out, const std::variant<std::vector<SymbolType>, std::pair<std::vector<SymbolType>, SymbolType>>& symbols) {
+	out.emplace_back("rhs", sax::Token::TokenType::START_ELEMENT);
+	if(symbols.template is<std::vector<SymbolType>>()) {
+		const std::vector<SymbolType>& rhs = symbols.template get<std::vector<SymbolType>>();
+		if(rhs.size() == 0) {
+			out.emplace_back("epsilon", sax::Token::TokenType::START_ELEMENT);
+			out.emplace_back("epsilon", sax::Token::TokenType::END_ELEMENT);
+		} else {
+			for (const auto& symbol : symbols.template get<std::vector<SymbolType>>()) {
+				alib::xmlApi<SymbolType>::compose(out, symbol);
+			}
+		}
+	} else {
+		const std::pair<std::vector<SymbolType>, SymbolType>& rhs = symbols.template get<std::pair<std::vector<SymbolType>, SymbolType>>();
+		for (const auto& symbol : rhs.first) {
+			alib::xmlApi<SymbolType>::compose(out, symbol);
+		}
+		alib::xmlApi<SymbolType>::compose(out, rhs.second);
+	}
+	out.emplace_back("rhs", sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace grammar */
 
 #endif /* GRAMMAR_TO_XML_COMPOSER_H_ */