From 76f8e9e0ab6fecd342891e9da638d22018e8ee0f Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 30 Nov 2016 16:33:37 +0100
Subject: [PATCH] template auxiliary parse & compose grammar helper

---
 .../common/AutomatonFromXMLParser.cpp         |  35 ---
 .../automaton/common/AutomatonFromXMLParser.h |  28 ++-
 .../common/AutomatonToXMLComposer.cpp         |  22 --
 .../automaton/common/AutomatonToXMLComposer.h |  11 +-
 alib2data/src/grammar/ContextFree/CFG.h       |  10 +-
 alib2data/src/grammar/ContextFree/CNF.h       |  10 +-
 .../src/grammar/ContextFree/EpsilonFreeCFG.h  |  10 +-
 alib2data/src/grammar/ContextFree/GNF.h       |  10 +-
 alib2data/src/grammar/ContextFree/LG.h        |  10 +-
 alib2data/src/grammar/ContextSensitive/CSG.h  |  14 +-
 .../ContextSensitive/NonContractingGrammar.h  |  10 +-
 alib2data/src/grammar/Regular/LeftLG.h        |  10 +-
 alib2data/src/grammar/Regular/LeftRG.h        |  10 +-
 alib2data/src/grammar/Regular/RightLG.h       |  10 +-
 alib2data/src/grammar/Regular/RightRG.h       |  10 +-
 .../ContextPreservingUnrestrictedGrammar.h    |  14 +-
 .../Unrestricted/UnrestrictedGrammar.h        |  10 +-
 .../grammar/common/GrammarFromXMLParser.cpp   | 142 -----------
 .../src/grammar/common/GrammarFromXMLParser.h | 173 ++++++++++++-
 .../grammar/common/GrammarToXMLComposer.cpp   | 190 --------------
 .../src/grammar/common/GrammarToXMLComposer.h | 231 ++++++++++++++++--
 21 files changed, 478 insertions(+), 492 deletions(-)
 delete mode 100644 alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
 delete mode 100644 alib2data/src/automaton/common/AutomatonToXMLComposer.cpp
 delete mode 100644 alib2data/src/grammar/common/GrammarFromXMLParser.cpp
 delete mode 100644 alib2data/src/grammar/common/GrammarToXMLComposer.cpp

diff --git a/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp b/alib2data/src/automaton/common/AutomatonFromXMLParser.cpp
deleted file mode 100644
index e6aef492b0..0000000000
--- 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 7a85c96a0f..7db611b852 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 afdbf758e5..0000000000
--- 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 bce807c2b8..b25d6685bf 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 f19a348597..90b583c9f7 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 6e3612ded7..bb27ac72bf 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 c3e4bff625..d4c39abbc7 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 3c98dfc4dd..f9c024c46a 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 80e172649c..37fbd2632d 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 eb75e88bf3..1a47c6eb20 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 1e8c149633..074b71b2c3 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 54c0282bd7..5f5655f23e 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 72b4d1ec8f..bd48006b08 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 c3a96ea097..e011f4ab65 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 c507c7eff3..947d092668 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 cbb9e13799..730b37603d 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 ce6bda2ea0..13c1d41f71 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 1a5364f516..0000000000
--- 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 08e4bcad85..2be7924315 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 ec867ec727..0000000000
--- 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 642a7dba49..2b5f14830a 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_ */
-- 
GitLab