diff --git a/alib2/src/ExceptionFeatures.h b/alib2/src/ExceptionFeatures.h
new file mode 100644
index 0000000000000000000000000000000000000000..d1757e13f6fd4e4e9266273774547b5b063db915
--- /dev/null
+++ b/alib2/src/ExceptionFeatures.h
@@ -0,0 +1,19 @@
+/*
+ * ExceptionFeatures.h
+ *
+ *  Created on: Jun 19, 2014
+ *      Author: Jan Travnicek
+ */
+
+#ifndef EXCEPTION_FEATURES_H_
+#define EXCEPTION_FEATURES_H_
+
+namespace alib {
+
+enum class FEATURES {
+	ALIB_EXCEPTION
+};
+
+} /* namespace alib */
+
+#endif /* EXCEPTION_FEATURES_H_ */
diff --git a/alib2/src/ExceptionFromXMLParser.cpp b/alib2/src/ExceptionFromXMLParser.cpp
index fe361b432f8bd05c8baa430c53aacb85231eaeed..3b72fff798c1edef11fbc94c6dd63f79f888cf0e 100644
--- a/alib2/src/ExceptionFromXMLParser.cpp
+++ b/alib2/src/ExceptionFromXMLParser.cpp
@@ -12,6 +12,11 @@
 namespace alib {
 
 AlibException ExceptionFromXMLParser::parse(std::list<sax::Token>& input) const {
+	return parse(input, std::set<FEATURES>({FEATURES::ALIB_EXCEPTION}));
+}
+
+AlibException ExceptionFromXMLParser::parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const {
+	if(!features.count(FEATURES::ALIB_EXCEPTION)) throw alib::AlibException();
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "exception");
 	std::string cause = "";
 	if (input.front().getType() == sax::Token::TokenType::CHARACTER) {
@@ -22,4 +27,12 @@ AlibException ExceptionFromXMLParser::parse(std::list<sax::Token>& input) const
 	return AlibException(cause);
 }
 
+bool ExceptionFromXMLParser::first(std::list<sax::Token>& input) const {
+	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "exception")) {
+		return true;
+	} else {
+		return false;
+	}
+}
+
 } /* namespace alib */
diff --git a/alib2/src/ExceptionFromXMLParser.h b/alib2/src/ExceptionFromXMLParser.h
index 3dbd8adfaf2328e66ea24a5d0b95ebbcd3e211a1..28646aa42ca559ccceed2b79c284e8a370e73200 100644
--- a/alib2/src/ExceptionFromXMLParser.h
+++ b/alib2/src/ExceptionFromXMLParser.h
@@ -9,7 +9,8 @@
 #define EXCEPTION_FROM_XML_PARSER_H_
 
 #include <list>
-#include "sax/FromXMLParser.h"
+#include "FromXMLParser.hpp"
+#include "ExceptionFeatures.h"
 #include "AlibException.h"
 
 namespace alib {
@@ -17,17 +18,11 @@ namespace alib {
 /**
  * Parser used to get String from XML parsed into list of tokens.
  */
-class ExceptionFromXMLParser : public sax::FromXMLParser {
-
+class ExceptionFromXMLParser : public FromXMLParser<AlibException, FEATURES> {
+	virtual AlibException parse(std::list<sax::Token>& input) const;
+	virtual AlibException parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
 public:
-	/**
-	 * Parses the XML and returns regular expression. The input is destroyed in the process.
-	 * @param input XML represented as list of tokens
-	 * @return AlibException
-	 * @throws ParserException when an error occurs
-	 */
-	AlibException parse(std::list<sax::Token>& input) const;
-
+	virtual bool first(std::list<sax::Token>& input) const;
 };
 
 } /* namespace alib */
diff --git a/alib2/src/FromXMLParser.hpp b/alib2/src/FromXMLParser.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..deb214c95c5224bdb0b2901fb19a1f2ac72d979e
--- /dev/null
+++ b/alib2/src/FromXMLParser.hpp
@@ -0,0 +1,64 @@
+/*
+ * FromXMLParser.h
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef FROM_XML_PARSER_H_
+#define FROM_XML_PARSER_H_
+
+#include "sax/FromXMLParserHelper.h"
+#include <list>
+#include <set>
+#include "sax/Token.h"
+#include "AlibException.h"
+
+namespace alib {
+
+/**
+ * Parser used to get String from XML parsed into list of tokens.
+ */
+template<class T, class F>
+class FromXMLParser : public sax::FromXMLParserHelper {
+	virtual T parse(std::list<sax::Token>& input) const = 0;
+	virtual T parse(std::list<sax::Token>& input, const std::set<F>& features) const = 0;
+
+public:
+	virtual bool first(std::list<sax::Token>& input) const = 0;
+
+	/**
+	 * Parses the XML tokens and returns symbol. The input is destroyed in the process.
+	 * @param input XML tokens represented as list of tokens
+	 * @return Symbol* the parsed symbol or NULL when by first token it is not a symbol
+	 * @throws ParserException when tokens do not represent Symbol but first token seemd as a symbol
+	 */
+	T* parsePointer(std::list<sax::Token>& input) const {
+		if(first(input)) {
+			return new T(parse(input));
+		} else {
+			return NULL;
+		}
+	}
+	
+	/**
+	 * Parses the XML tokens and returns symbol. The input is destroyed in the process.
+	 * @param input XML tokens represented as list of tokens
+	 * @return Symbol the parsed symbol
+	 * @throws ParserException when tokens do not represent Symbol
+	 */
+	T parseValue(std::list<sax::Token>& input) const {
+		T res = parse(input);
+
+		if(input.size() == 0) {
+			return res;
+		} else {
+			throw alib::AlibException();
+		}
+	}
+
+};
+
+} /* namespace alib */
+
+#endif /* FROM_XML_PARSER_HELPER_H_ */
diff --git a/alib2/src/alphabet/SymbolFromXMLParser.cpp b/alib2/src/alphabet/SymbolFromXMLParser.cpp
index ecedbacee7462018e411b10701d3d932cc3f5eef..6d41ec9e27f87206988360d51588f732b8dd5ae5 100644
--- a/alib2/src/alphabet/SymbolFromXMLParser.cpp
+++ b/alib2/src/alphabet/SymbolFromXMLParser.cpp
@@ -65,16 +65,6 @@ Symbol SymbolFromXMLParser::parseEndSymbol(std::list<sax::Token>& input) const {
 	return Symbol(EndSymbol());
 }
 
-Symbol SymbolFromXMLParser::parseValue(std::list<sax::Token>& input) const {
-	Symbol res = parse(input);
-
-	if(input.size() == 0) {
-		return res;
-	} else {
-		throw alib::AlibException();
-	}
-}
-
 bool SymbolFromXMLParser::first(std::list<sax::Token>& input) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "LabeledSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "BlankSymbol") || isToken(input, sax::Token::TokenType::START_ELEMENT, "BottomOfTheStackSymbol")) {
 		return true;
@@ -83,12 +73,4 @@ bool SymbolFromXMLParser::first(std::list<sax::Token>& input) const {
 	}
 }
 
-Symbol* SymbolFromXMLParser::parsePointer(std::list<sax::Token>& input) const {
-	if(first(input)) {
-		return new Symbol(parse(input));
-	} else {
-		return NULL;
-	}
-}
-
-} /* namespace string */
+} /* namespace alphabet */
diff --git a/alib2/src/alphabet/SymbolFromXMLParser.h b/alib2/src/alphabet/SymbolFromXMLParser.h
index 0c94b90089fbc26904f6fd6d599a7ee0dae1333b..85cca5ccace87fb4e0c5ab5720938c08e6db1bd9 100644
--- a/alib2/src/alphabet/SymbolFromXMLParser.h
+++ b/alib2/src/alphabet/SymbolFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef SYMBOL_FROM_XML_PARSER_H_
 #define SYMBOL_FROM_XML_PARSER_H_
 
-#include "../sax/FromXMLParser.h"
+#include "../FromXMLParser.hpp"
 #include <vector>
 #include <set>
 #include "Symbol.h"
@@ -39,32 +39,16 @@ namespace alphabet {
 /**
  * Parser used to get String from XML parsed into list of tokens.
  */
-class SymbolFromXMLParser : public sax::FromXMLParser {
-	Symbol parse(std::list<sax::Token>& input) const;
-	Symbol parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+class SymbolFromXMLParser : public alib::FromXMLParser<Symbol, FEATURES> {
+	virtual Symbol parse(std::list<sax::Token>& input) const;
+	virtual Symbol parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
 
 	Symbol parseLabeledSymbol(std::list<sax::Token>& input) const;
 	Symbol parseBlankSymbol(std::list<sax::Token>& input) const;
 	Symbol parseBottomOfTheStackSymbol(std::list<sax::Token>& input) const;
 	Symbol parseEndSymbol(std::list<sax::Token>& input) const;
 public:
-	bool first(std::list<sax::Token>& input) const;
-
-	/**
-	 * Parses the XML tokens and returns symbol. The input is destroyed in the process.
-	 * @param input XML tokens represented as list of tokens
-	 * @return Symbol* the parsed symbol or NULL when by first token it is not a symbol
-	 * @throws ParserException when tokens do not represent Symbol but first token seemd as a symbol
-	 */
-	Symbol* parsePointer(std::list<sax::Token>& input) const;
-	
-	/**
-	 * Parses the XML tokens and returns symbol. The input is destroyed in the process.
-	 * @param input XML tokens represented as list of tokens
-	 * @return Symbol the parsed symbol
-	 * @throws ParserException when tokens do not represent Symbol
-	 */
-	Symbol parseValue(std::list<sax::Token>& input) const;
+	virtual bool first(std::list<sax::Token>& input) const;
 
 	friend class string::StringFromXMLParser;
 	friend class regexp::RegExpFromXMLParser;
diff --git a/alib2/src/automaton/AutomatonFromXMLParser.cpp b/alib2/src/automaton/AutomatonFromXMLParser.cpp
index e3addc309e9d836e5b48469f071c1bf66bbba43b..a49d91db20d30e0a9fda9fb1d2a3f8b043bcc5e3 100644
--- a/alib2/src/automaton/AutomatonFromXMLParser.cpp
+++ b/alib2/src/automaton/AutomatonFromXMLParser.cpp
@@ -38,16 +38,6 @@ Automaton AutomatonFromXMLParser::parse(std::list<sax::Token>& input, const std:
 		throw sax::ParserException(sax::Token("Automaton / EpsilonNFA / NFA / DFA", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
-Automaton AutomatonFromXMLParser::parseValue(std::list<sax::Token>& input) const {
-	Automaton res = parse(input);
-
-	if(input.size() == 0) {
-		return res;
-	} else {
-		throw alib::AlibException();
-	}
-}
-
 bool AutomatonFromXMLParser::first(std::list<sax::Token>& input) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "automaton") || isToken(input, sax::Token::TokenType::START_ELEMENT, "EpsilonNFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "NFA") || isToken(input, sax::Token::TokenType::START_ELEMENT, "DFA")) {
 		return true;
@@ -56,14 +46,6 @@ bool AutomatonFromXMLParser::first(std::list<sax::Token>& input) const {
 	}
 }
 
-Automaton* AutomatonFromXMLParser::parsePointer(std::list<sax::Token>& input) const {
-	if(first(input)) {
-		return new Automaton(parse(input));
-	} else {
-		return NULL;
-	}
-}
-
 UnknownAutomaton AutomatonFromXMLParser::parseUnknownAutomaton(std::list<sax::Token> &input) const {
 	UnknownAutomaton automaton;
 
diff --git a/alib2/src/automaton/AutomatonFromXMLParser.h b/alib2/src/automaton/AutomatonFromXMLParser.h
index 2ec021aa8ef830d3910df86db621f565c1c10542..d21bf09c9242d84994a99d722a90397d4866314c 100644
--- a/alib2/src/automaton/AutomatonFromXMLParser.h
+++ b/alib2/src/automaton/AutomatonFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef AUTOMATON_FROM_XML_PARSER_H_
 #define AUTOMATON_FROM_XML_PARSER_H_
 
-#include "../sax/FromXMLParser.h"
+#include "../FromXMLParser.hpp"
 #include "Automaton.h"
 #include "AutomatonFeatures.h"
 #include "UnknownAutomaton.h"
@@ -26,7 +26,7 @@ namespace automaton {
 /**
  * Parser used to get general FSM or EpsilonNFA, NFA, DFA from XML parsed into list of Tokens.
  */
-class AutomatonFromXMLParser : public sax::FromXMLParser {
+class AutomatonFromXMLParser : public alib::FromXMLParser<Automaton, FEATURES> {
 protected:
 	std::string parseLabel(std::list<sax::Token> &input) const;
 
@@ -64,20 +64,10 @@ protected:
 	alphabet::Symbol parseSymbolIO(std::list<sax::Token> &input) const;
 	std::variant<string::Epsilon, alphabet::Symbol> parseEpsilonSymbolIO(std::list<sax::Token> &input) const;
 
-	Automaton parse(std::list<sax::Token>& input) const;
-	Automaton parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	virtual Automaton parse(std::list<sax::Token>& input) const;
+	virtual Automaton parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
 public:
-	bool first(std::list<sax::Token>& input) const;
-
-	Automaton* parsePointer(std::list<sax::Token>& input) const;
-
-	/**
-	 * Parses the xml and returns the automaton. The input is destroyed in the process.
-	 * @param input XML represented as list of Tokens
-	 * @return UnknownAutomaton
-	 * @throws ParserException when an error occurs
-	 */
-	Automaton parseValue(std::list<sax::Token> &input) const;
+	virtual bool first(std::list<sax::Token>& input) const;
 
 	UnknownAutomaton parseUnknownAutomaton(std::list<sax::Token>& input) const;
 	EpsilonNFA parseEpsilonNFA(std::list<sax::Token>& input) const;
diff --git a/alib2/src/label/LabelFromXMLParser.cpp b/alib2/src/label/LabelFromXMLParser.cpp
index 1b09a440d3ec195ebc937a9e2f3d3267ea3e6085..c3c6a8a295636fe820bfbf9a62db2063f984c8b5 100644
--- a/alib2/src/label/LabelFromXMLParser.cpp
+++ b/alib2/src/label/LabelFromXMLParser.cpp
@@ -42,16 +42,6 @@ Label LabelFromXMLParser::parse(std::list<sax::Token>& input, const std::set<FEA
 	}
 }
 
-Label LabelFromXMLParser::parseValue(std::list<sax::Token>& input) const {
-	Label label = parse(input);
-
-	if(input.size() == 0) {
-		return std::move(label);
-	} else {
-		throw new alib::AlibException();
-	}
-}
-
 bool LabelFromXMLParser::first(std::list<sax::Token>& input) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "IntegerLabel") || isToken(input, sax::Token::TokenType::START_ELEMENT, "StringLabel") || isToken(input, sax::Token::TokenType::START_ELEMENT, "CharacterLabel")) {
 		return true;
@@ -60,12 +50,4 @@ bool LabelFromXMLParser::first(std::list<sax::Token>& input) const {
 	}
 }
 
-Label* LabelFromXMLParser::parsePointer(std::list<sax::Token>& input) const {
-	if(first(input)) {
-		return new Label(parse(input));
-	} else {
-		return NULL;
-	}
-}
-
 } /* namespace label */
diff --git a/alib2/src/label/LabelFromXMLParser.h b/alib2/src/label/LabelFromXMLParser.h
index b2ee3d9fd3bf4cac53e465006cc25904872a77f8..84cf19ecab387dbcd04d0291a4c1f1752f1b82db 100644
--- a/alib2/src/label/LabelFromXMLParser.h
+++ b/alib2/src/label/LabelFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef LABEL_FROM_XML_PARSER_H_
 #define LABEL_FROM_XML_PARSER_H_
 
-#include "../sax/FromXMLParser.h"
+#include "../FromXMLParser.hpp"
 #include <vector>
 #include <set>
 #include "Label.h"
@@ -33,29 +33,13 @@ namespace label {
 /**
  * Parser used to transform sequence of xml tokens to internal representation of Label.
  */
-class LabelFromXMLParser : public sax::FromXMLParser {
-	Label parse(std::list<sax::Token>& input, const std::set<FEATURES>&) const;
+class LabelFromXMLParser : public alib::FromXMLParser<Label, FEATURES> {
+	virtual Label parse(std::list<sax::Token>& input, const std::set<FEATURES>&) const;
 	
-	Label parse(std::list<sax::Token>& input) const;
+	virtual Label parse(std::list<sax::Token>& input) const;
 
 public:
-	bool first(std::list<sax::Token>& input) const;
-
-	/**
-	 * Parses the XML tokens and returns label. The input is destroyed in the process.
-	 * @param input XML tokens represented as list of tokens
-	 * @return Label* the parsed label or NULL when by first token it is not a label
-	 * @throws ParserException when tokens do not represent Label but first token seemd as a label
-	 */
-	Label* parsePointer(std::list<sax::Token>& input) const;
-	
-	/**
-	 * Parses the XML tokens and returns label. The input is destroyed in the process.
-	 * @param input XML tokens represented as list of tokens
-	 * @return Label the parsed label
-	 * @throws ParserException when tokens do not represent Label
-	 */
-	Label parseValue(std::list<sax::Token>& input) const;
+	virtual bool first(std::list<sax::Token>& input) const;
 
 	friend class alphabet::SymbolFromXMLParser;
 
diff --git a/alib2/src/regexp/RegExpFromXMLParser.cpp b/alib2/src/regexp/RegExpFromXMLParser.cpp
index 0b6d12ed36cc3090a4b39fcaa7a62f6e5e4d68a5..bee69acdc4d89daaf598aacc42ee4e09f7b1c782 100644
--- a/alib2/src/regexp/RegExpFromXMLParser.cpp
+++ b/alib2/src/regexp/RegExpFromXMLParser.cpp
@@ -33,16 +33,6 @@ RegExp RegExpFromXMLParser::parse(std::list<sax::Token>& input, const std::set<F
 	return regexp;
 }
 
-RegExp RegExpFromXMLParser::parseValue(std::list<sax::Token>& input) const {
-	RegExp res = parse(input);
-
-	if(input.size() == 0) {
-		return res;
-	} else {
-		throw alib::AlibException();
-	}
-}
-
 bool RegExpFromXMLParser::first(std::list<sax::Token>& input) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "regexp")) {
 		return true;
@@ -51,14 +41,6 @@ bool RegExpFromXMLParser::first(std::list<sax::Token>& input) const {
 	}
 }
 
-RegExp* RegExpFromXMLParser::parsePointer(std::list<sax::Token>& input) const {
-	if(first(input)) {
-		return new RegExp(parse(input));
-	} else {
-		return NULL;
-	}
-}
-
 void RegExpFromXMLParser::parseAlphabet(std::list<sax::Token> &input, RegExp& regexp) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2/src/regexp/RegExpFromXMLParser.h b/alib2/src/regexp/RegExpFromXMLParser.h
index 04907e3adc3f03ad0427fc9e4cc3f449291e9530..2fa7c7e846927dcab6850b09c7d23d563deeffdc 100644
--- a/alib2/src/regexp/RegExpFromXMLParser.h
+++ b/alib2/src/regexp/RegExpFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef REG_EXP_FROM_XML_PARSER_H_
 #define REG_EXP_FROM_XML_PARSER_H_
 
-#include "../sax/FromXMLParser.h"
+#include "../FromXMLParser.hpp"
 #include "RegExp.h"
 #include "RegExpFeatures.h"
 #include "RegExpElements.h"
@@ -20,7 +20,7 @@ namespace regexp {
 /**
  * Parser used to get RegExp from XML parsed into list of tokens.
  */
-class RegExpFromXMLParser : public sax::FromXMLParser {
+class RegExpFromXMLParser : public alib::FromXMLParser<RegExp, FEATURES> {
 	void parseAlphabet(std::list<sax::Token>& input, RegExp& regexp) const;
 
 	RegExpElement* parseElement(std::list<sax::Token>& input) const;
@@ -31,20 +31,10 @@ class RegExpFromXMLParser : public sax::FromXMLParser {
 	Alternation* parseAlternation(std::list<sax::Token> &input) const;
 	Concatenation* parseConcatenation(std::list<sax::Token> &input) const;
 
-	RegExp parse(std::list<sax::Token>& input) const;
-	RegExp parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	virtual RegExp parse(std::list<sax::Token>& input) const;
+	virtual RegExp parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
 public:
-	bool first(std::list<sax::Token>& input) const;
-
-	RegExp* parsePointer(std::list<sax::Token>& input) const;
-	
-	/**
-	 * Parses the XML and returns regular expression. The input is destroyed in the process.
-	 * @param input XML represented as list of tokens
-	 * @return RegExp
-	 * @throws ParserException when an error occurs
-	 */
-	RegExp parseValue(std::list<sax::Token>& input) const;
+	virtual bool first(std::list<sax::Token>& input) const;
 };
 
 } /* namespace regexp */
diff --git a/alib2/src/sax/FromXMLParser.cpp b/alib2/src/sax/FromXMLParserHelper.cpp
similarity index 55%
rename from alib2/src/sax/FromXMLParser.cpp
rename to alib2/src/sax/FromXMLParserHelper.cpp
index c60ce1b174eafab9747393d85a2d410e686ca53a..9f0530826b71270e5733360f279497bd0cc98fc3 100644
--- a/alib2/src/sax/FromXMLParser.cpp
+++ b/alib2/src/sax/FromXMLParserHelper.cpp
@@ -1,24 +1,24 @@
 /*
- * FromXMLParser.cpp
+ * FromXMLParserHelper.cpp
  *
  *  Created on: Oct 12, 2013
  *      Author: Jan Travnicek
  */
 
-#include "FromXMLParser.h"
+#include "FromXMLParserHelper.h"
 #include "ParserException.h"
 
 namespace sax {
 
-bool FromXMLParser::isToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
+bool FromXMLParserHelper::isToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
 	return input.front().getType() == type && input.front().getData() == data;
 }
 
-bool FromXMLParser::isTokenType(std::list<Token>& input, Token::TokenType type) const {
+bool FromXMLParserHelper::isTokenType(std::list<Token>& input, Token::TokenType type) const {
 	return input.front().getType() == type;
 }
 
-void FromXMLParser::popToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
+void FromXMLParserHelper::popToken(std::list<Token>& input, Token::TokenType type, std::string data) const {
 	if (isToken(input, type, data)) {
 		input.pop_front();
 	} else {
@@ -26,7 +26,7 @@ void FromXMLParser::popToken(std::list<Token>& input, Token::TokenType type, std
 	}
 }
 
-std::string FromXMLParser::popTokenData(std::list<Token>& input, Token::TokenType type) const {
+std::string FromXMLParserHelper::popTokenData(std::list<Token>& input, Token::TokenType type) const {
 	if(isTokenType(input, type)) {
 		std::string result = input.front().getData();
 		input.pop_front();
diff --git a/alib2/src/sax/FromXMLParser.h b/alib2/src/sax/FromXMLParserHelper.h
similarity index 78%
rename from alib2/src/sax/FromXMLParser.h
rename to alib2/src/sax/FromXMLParserHelper.h
index 67b65c17f1d4f48aff902a8624b2cb067562cea6..c31def439bac3819a983b0e891366160846aae38 100644
--- a/alib2/src/sax/FromXMLParser.h
+++ b/alib2/src/sax/FromXMLParserHelper.h
@@ -1,12 +1,12 @@
 /*
- * FromXMLParser.h
+ * FromXMLParserHelper.h
  *
  *  Created on: Oct 12, 2013
  *      Author: Jan Travnicek
  */
 
-#ifndef FROM_XML_PARSER_H_
-#define FROM_XML_PARSER_H_
+#ifndef FROM_XML_PARSER_HELPER_H_
+#define FROM_XML_PARSER_HELPER_H_
 
 #include <list>
 #include "Token.h"
@@ -16,7 +16,7 @@ namespace sax {
 /**
  * Parser used to get UnknownAutomaton from XML parsed into list of Tokens.
  */
-class FromXMLParser {
+class FromXMLParserHelper {
 protected:
 	bool isToken(std::list<Token> &input, Token::TokenType type, std::string data) const;
 	bool isTokenType(std::list<Token>& input, Token::TokenType type) const;
@@ -27,5 +27,5 @@ protected:
 
 } /* namespace sax */
 
-#endif /* FROM_XML_PARSER_H_ */
+#endif /* FROM_XML_PARSER_HELPER_H_ */
 
diff --git a/alib2/src/string/StringFromXMLParser.cpp b/alib2/src/string/StringFromXMLParser.cpp
index 5f41dce449f012ecf317fb78fed1bfdefe4992f1..0aa3f44f4e362a1997942c40b15e478ac686af7c 100644
--- a/alib2/src/string/StringFromXMLParser.cpp
+++ b/alib2/src/string/StringFromXMLParser.cpp
@@ -62,16 +62,6 @@ void StringFromXMLParser::parseAlphabet(std::list<sax::Token> &input, String& st
 	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
 }
 
-String StringFromXMLParser::parseValue(std::list<sax::Token>& input) const {
-	String res = parse(input);
-
-	if(input.size() == 0) {
-		return res;
-	} else {
-		throw alib::AlibException();
-	}
-}
-
 bool StringFromXMLParser::first(std::list<sax::Token>& input) const {
 	if(isToken(input, sax::Token::TokenType::START_ELEMENT, "string")) {
 		return true;
@@ -80,14 +70,6 @@ bool StringFromXMLParser::first(std::list<sax::Token>& input) const {
 	}
 }
 
-String* StringFromXMLParser::parsePointer(std::list<sax::Token>& input) const {
-	if(first(input)) {
-		return new String(parse(input));
-	} else {
-		return NULL;
-	}
-}
-
 std::vector<alphabet::Symbol> StringFromXMLParser::parseContentData(std::list<sax::Token>& input) const {
 	std::vector<alphabet::Symbol> data;
 	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
diff --git a/alib2/src/string/StringFromXMLParser.h b/alib2/src/string/StringFromXMLParser.h
index 2da6ded4e50877e858e64616838f60103821cd89..8c45a48670da0cfb81013e88baf542e31df31710 100644
--- a/alib2/src/string/StringFromXMLParser.h
+++ b/alib2/src/string/StringFromXMLParser.h
@@ -8,7 +8,7 @@
 #ifndef STRING_FROM_XML_PARSER_H_
 #define STRING_FROM_XML_PARSER_H_
 
-#include "../sax/FromXMLParser.h"
+#include "../FromXMLParser.hpp"
 #include <vector>
 #include <set>
 #include "String.h"
@@ -21,25 +21,15 @@ namespace string {
 /**
  * Parser used to get String from XML parsed into list of tokens.
  */
-class StringFromXMLParser : public sax::FromXMLParser {
+class StringFromXMLParser : public alib::FromXMLParser<String, FEATURES> {
 	void parseContent(std::list<sax::Token>& input, String& string, const std::set<FEATURES>& features) const;
 	std::vector<alphabet::Symbol> parseContentData(std::list<sax::Token>& input) const;
 	void parseAlphabet(std::list<sax::Token> &input, String& string) const;
 
-	String parse(std::list<sax::Token>& input) const;
-	String parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
+	virtual String parse(std::list<sax::Token>& input) const;
+	virtual String parse(std::list<sax::Token>& input, const std::set<FEATURES>& features) const;
 public:
-	bool first(std::list<sax::Token>& input) const;
-	String* parsePointer(std::list<sax::Token>& input) const;
-
-	/**
-	 * Parses the XML and returns regular expression. The input is destroyed in the process.
-	 * @param input XML represented as list of tokens
-	 * @return String
-	 * @throws ParserException when an error occurs
-	 */
-	String parseValue(std::list<sax::Token>& input) const;
-
+	virtual bool first(std::list<sax::Token>& input) const;
 };
 
 } /* namespace string */