diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 9361e51eacb8d743cf9eda26409e558b605589e5..21612e75a486afc5119b7c7cf88361157f7b7502 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -38,7 +38,6 @@ const grammar::GrammarFromXMLParser FromXMLParsers::grammarParser;
 const graph::GraphFromXMLParser FromXMLParsers::graphParser;
 const alib::ObjectFromXMLParser FromXMLParsers::objectParser;
 const container::ContainerFromXMLParser FromXMLParsers::containerParser;
-const tree::TreeFromXMLParser FromXMLParsers::treeParser;
 
 const regexp::RegExpToXMLComposer ToXMLComposers::regexpComposer;
 const automaton::AutomatonToXMLComposer ToXMLComposers::automatonComposer;
@@ -46,7 +45,6 @@ const grammar::GrammarToXMLComposer ToXMLComposers::grammarComposer;
 const graph::GraphToXMLComposer ToXMLComposers::graphComposer;
 const alib::ObjectToXMLComposer ToXMLComposers::objectComposer;
 const container::ContainerToXMLComposer ToXMLComposers::containerComposer;
-const tree::TreeToXMLComposer ToXMLComposers::treeComposer;
 
 const ToXMLComposers ToXMLComposers::toXMLComposers;
 
@@ -631,114 +629,6 @@ void xmlApi<regexp::FormalRegExp>::compose(std::deque<sax::Token>& output, const
 }
 
 
-tree::Tree xmlApi<tree::Tree>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parseTree(input);
-}
-
-bool xmlApi<tree::Tree>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return FromXMLParsers::treeParser.first(input);
-}
-
-void xmlApi<tree::Tree>::compose(std::deque<sax::Token>& output, const tree::Tree& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::PrefixRankedTree xmlApi<tree::PrefixRankedTree>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parsePrefixRankedTree(input);
-}
-
-bool xmlApi<tree::PrefixRankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_TREE);
-}
-
-void xmlApi<tree::PrefixRankedTree>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedTree& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::PrefixRankedBarTree xmlApi<tree::PrefixRankedBarTree>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parsePrefixRankedBarTree(input);
-}
-
-bool xmlApi<tree::PrefixRankedBarTree>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_BAR_TREE);
-}
-
-void xmlApi<tree::PrefixRankedBarTree>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarTree& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::PrefixRankedPattern xmlApi<tree::PrefixRankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parsePrefixRankedPattern(input);
-}
-
-bool xmlApi<tree::PrefixRankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_PATTERN);
-}
-
-void xmlApi<tree::PrefixRankedPattern>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::PrefixRankedBarPattern xmlApi<tree::PrefixRankedBarPattern>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parsePrefixRankedBarPattern(input);
-}
-
-bool xmlApi<tree::PrefixRankedBarPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_BAR_PATTERN);
-}
-
-void xmlApi<tree::PrefixRankedBarPattern>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarPattern& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::RankedTree xmlApi<tree::RankedTree>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parseRankedTree(input);
-}
-
-bool xmlApi<tree::RankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_RANKED_TREE);
-}
-
-void xmlApi<tree::RankedTree>::compose(std::deque<sax::Token>& output, const tree::RankedTree& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::RankedPattern xmlApi<tree::RankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parseRankedPattern(input);
-}
-
-bool xmlApi<tree::RankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_RANKED_PATTERN);
-}
-
-void xmlApi<tree::RankedPattern>::compose(std::deque<sax::Token>& output, const tree::RankedPattern& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::UnrankedTree xmlApi<tree::UnrankedTree>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parseUnrankedTree(input);
-}
-
-bool xmlApi<tree::UnrankedTree>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_UNRANKED_TREE);
-}
-
-void xmlApi<tree::UnrankedTree>::compose(std::deque<sax::Token>& output, const tree::UnrankedTree& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
-tree::UnrankedPattern xmlApi<tree::UnrankedPattern>::parse(std::deque<sax::Token>::iterator& input) {
-	return FromXMLParsers::treeParser.parseUnrankedPattern(input);
-}
-
-bool xmlApi<tree::UnrankedPattern>::first(const std::deque<sax::Token>::const_iterator& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_UNRANKED_PATTERN);
-}
-
-void xmlApi<tree::UnrankedPattern>::compose(std::deque<sax::Token>& output, const tree::UnrankedPattern& data) {
-	ToXMLComposers::treeComposer.compose(output, data);
-}
-
 void ToXMLComposers::Visit(void* data, const Void& voidObject) const {
 	xmlApi<Void>::compose(*((std::deque<sax::Token>*) data), voidObject);
 }
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index c2ef8831333e3b222a1bc3d9c7c4e4fd2847ea86..c34e5764e1ed439b1b6f93af66e9aad849da7533 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -24,7 +24,6 @@
 #include "grammar/GrammarFromXMLParser.h"
 #include "graph/GraphFromXMLParser.h"
 #include "object/ObjectFromXMLParser.h"
-#include "tree/TreeFromXMLParser.h"
 #include "container/ContainerFromXMLParser.hpp"
 
 #include "regexp/RegExpToXMLComposer.h"
@@ -32,7 +31,6 @@
 #include "grammar/GrammarToXMLComposer.h"
 #include "graph/GraphToXMLComposer.h"
 #include "object/ObjectToXMLComposer.h"
-#include "tree/TreeToXMLComposer.h"
 #include "container/ContainerToXMLComposer.hpp"
 
 #include "object/ObjectBase.h"
@@ -480,69 +478,6 @@ struct xmlApi<regexp::FormalRegExp> {
 };
 
 
-template<>
-struct xmlApi<tree::Tree> {
-	static tree::Tree parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::Tree& data);
-};
-
-template<>
-struct xmlApi<tree::RankedTree> {
-	static tree::RankedTree parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::RankedTree& data);
-};
-
-template<>
-struct xmlApi<tree::RankedPattern> {
-	static tree::RankedPattern parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::RankedPattern& data);
-};
-
-template<>
-struct xmlApi<tree::PrefixRankedTree> {
-	static tree::PrefixRankedTree parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedTree& data);
-};
-
-template<>
-struct xmlApi<tree::PrefixRankedBarTree> {
-	static tree::PrefixRankedBarTree parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarTree& data);
-};
-
-template<>
-struct xmlApi<tree::PrefixRankedPattern> {
-	static tree::PrefixRankedPattern parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data);
-};
-
-template<>
-struct xmlApi<tree::PrefixRankedBarPattern> {
-	static tree::PrefixRankedBarPattern parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarPattern& data);
-};
-
-template<>
-struct xmlApi<tree::UnrankedTree> {
-	static tree::UnrankedTree parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::UnrankedTree& data);
-};
-
-template<>
-struct xmlApi<tree::UnrankedPattern> {
-	static tree::UnrankedPattern parse(std::deque<sax::Token>::iterator& input);
-	static bool first(const std::deque<sax::Token>::const_iterator& input);
-	static void compose(std::deque<sax::Token>& output, const tree::UnrankedPattern& data);
-};
-
 template<>
 struct xmlApi<container::Container> {
 	static container::Container parse(std::deque<sax::Token>::iterator& input);
@@ -558,7 +493,6 @@ public:
 	static const graph::GraphFromXMLParser graphParser;
 	static const ObjectFromXMLParser objectParser;
 	static const container::ContainerFromXMLParser containerParser;
-	static const tree::TreeFromXMLParser treeParser;
 
 };
 
@@ -662,7 +596,6 @@ public:
 	static const graph::GraphToXMLComposer graphComposer;
 	static const ObjectToXMLComposer objectComposer;
 	static const container::ContainerToXMLComposer containerComposer;
-	static const tree::TreeToXMLComposer treeComposer;
 
 	static const ToXMLComposers toXMLComposers;
 };
diff --git a/alib2data/src/XmlTagNames.cpp b/alib2data/src/XmlTagNames.cpp
index 27d602fe4973d1dbd38a093340540afa1b2c0d6b..9a90210b76cce44d3847c1e3c873a2bfe19fcaf1 100644
--- a/alib2data/src/XmlTagNames.cpp
+++ b/alib2data/src/XmlTagNames.cpp
@@ -56,14 +56,6 @@ const std::string Names::LABEL_LABEL_PAIR_LABEL = "LabelPairLabel";
 const std::string Names::LABEL_UNIQUE_LABEL = "UniqueLabel";
 const std::string Names::REGEXP_UNBOUNDED_REGEXP = "UnboundedRegExp";
 const std::string Names::REGEXP_FORMAL_REGEXP = "FormalRegExp";
-const std::string Names::TREE_RANKED_TREE = "RankedTree";
-const std::string Names::TREE_RANKED_PATTERN = "RankedPattern";
-const std::string Names::TREE_PREFIX_RANKED_TREE = "PrefixRankedTree";
-const std::string Names::TREE_PREFIX_RANKED_BAR_TREE = "PrefixRankedBarTree";
-const std::string Names::TREE_PREFIX_RANKED_PATTERN = "PrefixRankedPattern";
-const std::string Names::TREE_PREFIX_RANKED_BAR_PATTERN = "PrefixRankedBarPattern";
-const std::string Names::TREE_UNRANKED_TREE = "UnrankedTree";
-const std::string Names::TREE_UNRANKED_PATTERN = "UnrankedPattern";
 
 }
 
diff --git a/alib2data/src/XmlTagNames.h b/alib2data/src/XmlTagNames.h
index e96480def2040e0d33d612ce3c316a1c29c81fc3..fd23b50fa6384a61231340749aa8d5adccdadc61 100644
--- a/alib2data/src/XmlTagNames.h
+++ b/alib2data/src/XmlTagNames.h
@@ -61,14 +61,6 @@ struct Names {
 	const static std::string LABEL_UNIQUE_LABEL;
 	const static std::string REGEXP_UNBOUNDED_REGEXP;
 	const static std::string REGEXP_FORMAL_REGEXP;
-	const static std::string TREE_RANKED_TREE;
-	const static std::string TREE_RANKED_PATTERN;
-	const static std::string TREE_PREFIX_RANKED_TREE;
-	const static std::string TREE_PREFIX_RANKED_BAR_TREE;
-	const static std::string TREE_PREFIX_RANKED_PATTERN;
-	const static std::string TREE_PREFIX_RANKED_BAR_PATTERN;
-	const static std::string TREE_UNRANKED_TREE;
-	const static std::string TREE_UNRANKED_PATTERN;
 
 };
 
diff --git a/alib2data/src/tree/TreeBase.h b/alib2data/src/tree/TreeBase.h
index 5f85a2a53a15850e1e97fa3a5af0549b3a4fb8ea..9d716d4a69746b04df4fe5e019ba22b835701dcc 100644
--- a/alib2data/src/tree/TreeBase.h
+++ b/alib2data/src/tree/TreeBase.h
@@ -9,6 +9,8 @@
 #define TREE_BASE_H_
 
 #include "../object/ObjectBase.h"
+#include <deque>
+#include "../sax/Token.h"
 
 namespace tree {
 
@@ -42,6 +44,7 @@ public:
 	virtual TreeBase* clone() const = 0;
 	virtual TreeBase* plunder() && = 0;
 
+	virtual void compose(std::deque<sax::Token>& out) const = 0;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/TreeFromXMLParser.cpp b/alib2data/src/tree/TreeFromXMLParser.cpp
deleted file mode 100644
index a5e67f91ba56b7cb8fa8be0d150ae113c031e356..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/TreeFromXMLParser.cpp
+++ /dev/null
@@ -1,229 +0,0 @@
-/*
- * TreeFromXMLParser.cpp
- *
- *  Created on: Nov 16, 2014
- *      Author: Stepan Plachy
- */
-
-#include "TreeFromXMLParser.h"
-#include "../sax/ParserException.h"
-#include "../XmlApi.hpp"
-
-#include "Tree.h"
-#include "TreeClasses.h"
-
-namespace tree {
-
-Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>::iterator& input) const {
-	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::RANKED_PATTERN, FEATURES::UNRANKED_TREE, FEATURES::UNRANKED_PATTERN, FEATURES::PREFIX_RANKED_TREE, FEATURES::PREFIX_RANKED_PATTERN, FEATURES::PREFIX_RANKED_BAR_PATTERN}));
-}
-
-Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const {
-	if(alib::xmlApi<RankedTree>::first(input)) {
-		if(!features.count(FEATURES::RANKED_TREE)) throw exception::AlibException();
-		return Tree(parseRankedTree(input));
-	} else if(alib::xmlApi<RankedPattern>::first(input)) {
-		if(!features.count(FEATURES::RANKED_PATTERN)) throw exception::AlibException();
-		return Tree(parseRankedPattern(input));
-	} else if(alib::xmlApi<UnrankedTree>::first(input)) {
-		if(!features.count(FEATURES::UNRANKED_TREE)) throw exception::AlibException();
-		return Tree(parseUnrankedTree(input));
-	} else if(alib::xmlApi<UnrankedPattern>::first(input)) {
-		if(!features.count(FEATURES::UNRANKED_PATTERN)) throw exception::AlibException();
-		return Tree(parseUnrankedPattern(input));
-	} else if(alib::xmlApi<PrefixRankedTree>::first(input)) {
-		if(!features.count(FEATURES::PREFIX_RANKED_TREE)) throw exception::AlibException();
-		return Tree(parsePrefixRankedTree(input));
-	} else if(alib::xmlApi<PrefixRankedPattern>::first(input)) {
-		if(!features.count(FEATURES::PREFIX_RANKED_PATTERN)) throw exception::AlibException();
-		return Tree(parsePrefixRankedPattern(input));
-	} else if(alib::xmlApi<PrefixRankedBarPattern>::first(input)) {
-		if(!features.count(FEATURES::PREFIX_RANKED_BAR_PATTERN)) throw exception::AlibException();
-		return Tree(parsePrefixRankedBarPattern(input));
-	} else
-		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / PrefixRankedBarPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), *input);
-}
-
-RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_PATTERN);
-
-	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	RankedNode * root = parseRankedNode(input);
-	RankedPattern tree(subtreeWildcard, std::move(rankedAlphabet), std::move(*root));
-	delete root;
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_RANKED_PATTERN);
-	return tree;
-}
-
-RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_RANKED_TREE);
-
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	RankedNode * root = parseRankedNode(input);
-	RankedTree tree(std::move(rankedAlphabet), std::move(*root));
-	delete root;
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_RANKED_TREE);
-	return tree;
-}
-
-PrefixRankedTree TreeFromXMLParser::parsePrefixRankedTree(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_TREE);
-
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
-	PrefixRankedTree tree(std::move(rankedAlphabet), std::move(data));
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_TREE);
-	return tree;
-}
-
-PrefixRankedBarTree TreeFromXMLParser::parsePrefixRankedBarTree(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_TREE);
-
-	alphabet::Symbol bar = parseBar(input);
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
-	PrefixRankedBarTree tree(std::move(bar), std::move(rankedAlphabet), std::move(data));
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_TREE);
-	return tree;
-}
-
-PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_PATTERN);
-
-	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
-	PrefixRankedPattern tree(std::move(subtreeWildcard), std::move(rankedAlphabet), std::move(data));
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_PATTERN);
-	return tree;
-}
-
-PrefixRankedBarPattern TreeFromXMLParser::parsePrefixRankedBarPattern(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN);
-
-	alphabet::Symbol bar = parseBar(input);
-	alphabet::Symbol variablesBar = parseVariablesBar(input);
-	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
-	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
-	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
-	PrefixRankedBarPattern tree(std::move(bar), std::move(variablesBar), std::move(subtreeWildcard), std::move(rankedAlphabet), std::move(data));
-
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN);
-	return tree;
-}
-
-UnrankedPattern TreeFromXMLParser::parseUnrankedPattern(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_PATTERN);
-
-	alphabet::Symbol subtreeWildcard = parseSubtreeWildcard<alphabet::Symbol>(input);
-	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
-	UnrankedNode * root = parseUnrankedNode(input);
-	UnrankedPattern tree(std::move(subtreeWildcard), std::move(alphabet), std::move(*root));
-	delete root;
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_UNRANKED_PATTERN);
-	return tree;
-}
-
-UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
-
-	std::set<alphabet::Symbol> alphabet = parseAlphabet(input);
-	UnrankedNode * root = parseUnrankedNode(input);
-	UnrankedTree tree(std::move(alphabet), std::move(*root));
-	delete root;
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_UNRANKED_TREE);
-	return tree;
-}
-
-alphabet::Symbol TreeFromXMLParser::parseBar(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "bar");
-	alphabet::Symbol bar(alib::xmlApi<alphabet::Symbol>::parse(input));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "bar");
-	return bar;
-}
-
-alphabet::Symbol TreeFromXMLParser::parseVariablesBar(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "variablesBar");
-	alphabet::Symbol variablesBar(alib::xmlApi<alphabet::Symbol>::parse(input));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "variablesBar");
-	return variablesBar;
-}
-
-template<class T>
-T TreeFromXMLParser::parseSubtreeWildcard(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "subtreeWildcard");
-	T subtreeWildcard(alib::xmlApi<T>::parse(input));
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "subtreeWildcard");
-	return subtreeWildcard;
-}
-
-std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token>::iterator& input) const {
-	std::set<alphabet::RankedSymbol> rankedSymbols;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedAlphabet");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		rankedSymbols.insert(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedAlphabet");
-	return rankedSymbols;
-}
-
-std::set<alphabet::Symbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input) const {
-	std::set<alphabet::Symbol> symbols;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		symbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
-	return symbols;
-}
-
-std::vector<alphabet::RankedSymbol> TreeFromXMLParser::parseContentData(std::deque<sax::Token>::iterator& input) const {
-	std::vector<alphabet::RankedSymbol> data;
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		data.push_back(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "content");
-	return data;
-}
-
-RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedNode");
-	alphabet::RankedSymbol symbol = alib::xmlApi<alphabet::RankedSymbol>::parse(input);
-	int rank = symbol.getRank().getData();
-	std::vector<RankedNode *> children;
-	children.reserve(rank);
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		children.push_back(parseRankedNode(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedNode");
-
-	return new RankedNode(symbol, children);
-}
-
-UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token>::iterator& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, "unrankedNode");
-	alphabet::Symbol symbol = alib::xmlApi<alphabet::Symbol>::parse(input);
-	std::vector<UnrankedNode *> children;
-	while (isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
-		children.push_back(parseUnrankedNode(input));
-	}
-	popToken(input, sax::Token::TokenType::END_ELEMENT, "unrankedNode");
-
-	return new UnrankedNode(symbol, children);
-}
-
-bool TreeFromXMLParser::first(const std::deque<sax::Token>::const_iterator& input) const {
-	if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<RankedPattern>::first(input) || alib::xmlApi<PrefixRankedTree>::first(input)  || alib::xmlApi<PrefixRankedPattern>::first(input) || alib::xmlApi<UnrankedTree>::first(input) || alib::xmlApi<UnrankedPattern>::first(input)) {
-		return true;
-	} else {
-		return false;
-	}
-}
-
-} /* namespace tree */
-
diff --git a/alib2data/src/tree/TreeFromXMLParser.h b/alib2data/src/tree/TreeFromXMLParser.h
deleted file mode 100644
index 63a30e44ae468407ac258728663e304f88ddfc1a..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/TreeFromXMLParser.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * TreeFromXMLParser.h
- *
- *  Created on: Nov 16, 2014
- *      Author: Stepan Plachy
- */
-
-#ifndef TREE_FROM_XML_PARSER_H_
-#define TREE_FROM_XML_PARSER_H_
-
-#include "../sax/FromXMLParserHelper.h"
-#include "TreeFeatures.h"
-
-#include <set>
-#include <variant>
-#include <vector>
-
-#include "../alphabet/SymbolFeatures.h"
-#include "../XmlApiBase.h"
-
-namespace tree {
-
-/**
- * Parser used to get tree from XML parsed into list of Tokens.
- */
-class TreeFromXMLParser : public sax::FromXMLParserHelper {
-public:
-	TreeFromXMLParser() {}
-
-private:
-	RankedNode * parseRankedNode(std::deque<sax::Token>::iterator& input) const;
-	std::vector<alphabet::RankedSymbol> parseContentData(std::deque<sax::Token>::iterator& input) const;
-	UnrankedNode * parseUnrankedNode(std::deque<sax::Token>::iterator& input) const;
-	std::set<alphabet::RankedSymbol> parseRankedAlphabet(std::deque<sax::Token>::iterator& input) const;
-	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token>::iterator& input) const;
-
-	alphabet::Symbol parseBar(std::deque<sax::Token>::iterator& input) const;
-	alphabet::Symbol parseVariablesBar(std::deque<sax::Token>::iterator& input) const;
-
-	template<class T>
-	T parseSubtreeWildcard(std::deque<sax::Token>::iterator& input) const;
-
-	Tree parseTree(std::deque<sax::Token>::iterator& input) const;
-	Tree parseTree(std::deque<sax::Token>::iterator& input, const std::set<FEATURES>& features) const;
-
-	RankedTree parseRankedTree(std::deque<sax::Token>::iterator& input) const;
-	RankedPattern parseRankedPattern(std::deque<sax::Token>::iterator& input) const;
-	PrefixRankedTree parsePrefixRankedTree(std::deque<sax::Token>::iterator& input) const;
-	PrefixRankedBarTree parsePrefixRankedBarTree(std::deque<sax::Token>::iterator& input) const;
-	PrefixRankedPattern parsePrefixRankedPattern(std::deque<sax::Token>::iterator& input) const;
-	PrefixRankedBarPattern parsePrefixRankedBarPattern(std::deque<sax::Token>::iterator& input) const;
-	UnrankedTree parseUnrankedTree(std::deque<sax::Token>::iterator& input) const;
-	UnrankedPattern parseUnrankedPattern(std::deque<sax::Token>::iterator& input) const;
-
-	template<typename T, typename Enable> friend struct alib::xmlApi;
-public:
-	bool first(const std::deque<sax::Token>::const_iterator& input) const;
-};
-
-} /* namespace tree */
-
-#endif /* TREE_FROM_XML_PARSER_H_ */
-
diff --git a/alib2data/src/tree/TreeToXMLComposer.cpp b/alib2data/src/tree/TreeToXMLComposer.cpp
deleted file mode 100644
index ba1b5e4cdac26503f3d3908f8ce73b39a617c6c6..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/TreeToXMLComposer.cpp
+++ /dev/null
@@ -1,174 +0,0 @@
-/*
- * TreeToXMLComposer.cpp
- *
- *  Created on: Nov 16, 2014
- *      Author: Stepan Plachy
- */
-
-#include "TreeToXMLComposer.h"
-#include "../XmlApi.hpp"
-#include "Tree.h"
-#include "TreeClasses.h"
-
-namespace tree {
-
-void TreeToXMLComposer::composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.emplace_back(sax::Token("bar", sax::Token::TokenType::START_ELEMENT));
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back(sax::Token("bar", sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::composeVariablesBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
-	out.emplace_back(sax::Token("variablesBar", sax::Token::TokenType::START_ELEMENT));
-	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	out.emplace_back(sax::Token("variablesBar", sax::Token::TokenType::END_ELEMENT));
-}
-
-template<class T>
-void TreeToXMLComposer::composeSubtreeWildcard(std::deque<sax::Token>& out, const T& symbol) const {
-	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::START_ELEMENT));
-	alib::xmlApi<T>::compose(out, symbol);
-	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols) const {
-	out.emplace_back(sax::Token("rankedAlphabet", sax::Token::TokenType::START_ELEMENT));
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
-	}
-	out.emplace_back(sax::Token("rankedAlphabet", sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const {
-	out.emplace_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
-	for (const auto& symbol : symbols) {
-		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
-	}
-	out.emplace_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const TreeBase& tree) const {
-	tree.Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const Tree& tree) const {
-	tree.getData().Accept((void*) &out, alib::ToXMLComposers::toXMLComposers);
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const RankedTree& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_RANKED_TREE, sax::Token::TokenType::START_ELEMENT));
-
-	composeAlphabet(out, tree.getAlphabet());
-	composeNode(out, tree.getRoot());
-
-	out.emplace_back(sax::Token(alib::Names::TREE_RANKED_TREE, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const RankedPattern& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_RANKED_PATTERN, sax::Token::TokenType::START_ELEMENT));
-
-	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
-	composeAlphabet(out, tree.getAlphabet());
-	composeNode(out, tree.getRoot());
-
-	out.emplace_back(sax::Token(alib::Names::TREE_RANKED_PATTERN, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_TREE, sax::Token::TokenType::START_ELEMENT));
-
-	composeAlphabet(out, tree.getAlphabet());
-	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& symbol : tree.getContent()) {
-		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
-	}
-	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
-
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_TREE, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedBarTree& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_TREE, sax::Token::TokenType::START_ELEMENT));
-
-	composeBar(out, tree.getBarSymbol());
-	composeAlphabet(out, tree.getAlphabet());
-	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& symbol : tree.getContent()) {
-		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
-	}
-	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
-
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_TREE, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedBarPattern& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN, sax::Token::TokenType::START_ELEMENT));
-
-	composeBar(out, tree.getBarSymbol());
-	composeVariablesBar(out, tree.getVariablesBarSymbol());
-	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
-	composeAlphabet(out, tree.getAlphabet());
-	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& symbol : tree.getContent()) {
-		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
-	}
-	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
-
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_PATTERN, sax::Token::TokenType::START_ELEMENT));
-
-	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
-	composeAlphabet(out, tree.getAlphabet());
-	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& symbol : tree.getContent()) {
-		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
-	}
-	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
-
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_PATTERN, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_UNRANKED_TREE, sax::Token::TokenType::START_ELEMENT));
-
-	composeAlphabet(out, tree.getAlphabet());
-	composeNode(out, tree.getRoot());
-
-	out.emplace_back(sax::Token(alib::Names::TREE_UNRANKED_TREE, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const UnrankedPattern& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_UNRANKED_PATTERN, sax::Token::TokenType::START_ELEMENT));
-
-	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
-	composeAlphabet(out, tree.getAlphabet());
-	composeNode(out, tree.getRoot());
-
-	out.emplace_back(sax::Token(alib::Names::TREE_UNRANKED_PATTERN, sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::composeNode(std::deque<sax::Token>& out, const RankedNode& node) const {
-	out.emplace_back(sax::Token("rankedNode", sax::Token::TokenType::START_ELEMENT));
-	alib::xmlApi<alphabet::RankedSymbol>::compose(out, node.getSymbol());
-	for(const auto& child : node.getChildren()) {
-		composeNode(out, *child);
-	}
-
-	out.emplace_back(sax::Token("rankedNode", sax::Token::TokenType::END_ELEMENT));
-}
-
-void TreeToXMLComposer::composeNode(std::deque<sax::Token>& out, const UnrankedNode& node) const {
-	out.emplace_back(sax::Token("unrankedNode", sax::Token::TokenType::START_ELEMENT));
-	alib::xmlApi<alphabet::Symbol>::compose(out, node.getSymbol());
-	for(const auto& child : node.getChildren()) {
-		composeNode(out, *child);
-	}
-
-	out.emplace_back(sax::Token("unrankedNode", sax::Token::TokenType::END_ELEMENT));
-}
-
-} /* namespace automaton */
-
diff --git a/alib2data/src/tree/TreeToXMLComposer.h b/alib2data/src/tree/TreeToXMLComposer.h
deleted file mode 100644
index c1e2563b356e6b6e67890c4ff8cc9641a89aad2c..0000000000000000000000000000000000000000
--- a/alib2data/src/tree/TreeToXMLComposer.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
- * TreeToXMLComposer.h
- *
- *  Created on: Nov 16, 2014
- *      Author: Stepan Plachy
- */
-
-#ifndef TREE_TO_XML_COMPOSER_H_
-#define TREE_TO_XML_COMPOSER_H_
-
-#include <deque>
-#include "TreeFeatures.h"
-#include "../alphabet/SymbolFeatures.h"
-#include "../sax/Token.h"
-#include <set>
-#include "../XmlApiBase.h"
-
-namespace tree {
-
-/**
- * This class contains methods to print XML representation of tree to the output stream.
- */
-class TreeToXMLComposer {
-public:
-	TreeToXMLComposer() {}
-
-private:
-	void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols) const;
-	void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
-
-	void composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
-	void composeVariablesBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
-
-	template<class T>
-	void composeSubtreeWildcard(std::deque<sax::Token>& out, const T& symbol) const;
-
-	/**
-	 * Prints XML representation of Tree to the output stream.
-	 * @param tree tree to print
-	 * @return list of xml tokens representing the tree
-	 */
-	void compose(std::deque<sax::Token>& out, const TreeBase& tree) const;
-	void compose(std::deque<sax::Token>& out, const Tree& tree) const;
-
-	void compose(std::deque<sax::Token>& out, const RankedTree& tree) const;
-	void compose(std::deque<sax::Token>& out, const RankedPattern& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedBarTree& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedBarPattern& tree) const;
-	void compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const;
-	void compose(std::deque<sax::Token>& out, const UnrankedPattern& tree) const;
-
-	void composeNode(std::deque<sax::Token>& out, const RankedNode& node) const;
-	void composeNode(std::deque<sax::Token>& out, const UnrankedNode& node) const;
-
-	template<typename T, typename Enable> friend struct alib::xmlApi;
-};
-
-} /* namespace tree */
-
-#endif /* TREE_TO_XML_COMPOSER_H_ */
-
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.cpp b/alib2data/src/tree/common/TreeFromXMLParser.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b486e10a5f688a48bf9d1a2bbe14b62fac0096f4
--- /dev/null
+++ b/alib2data/src/tree/common/TreeFromXMLParser.cpp
@@ -0,0 +1,100 @@
+/*
+ * TreeFromXMLParser.cpp
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#include "../../sax/FromXMLParserHelper.h"
+#include "TreeFromXMLParser.h"
+#include "../../sax/ParserException.h"
+#include "../../XmlApi.hpp"
+
+namespace tree {
+
+alphabet::Symbol TreeFromXMLParser::parseBar(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "bar");
+	alphabet::Symbol bar(alib::xmlApi<alphabet::Symbol>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "bar");
+	return bar;
+}
+
+alphabet::Symbol TreeFromXMLParser::parseVariablesBar(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "variablesBar");
+	alphabet::Symbol variablesBar(alib::xmlApi<alphabet::Symbol>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "variablesBar");
+	return variablesBar;
+}
+
+alphabet::Symbol TreeFromXMLParser::parseSubtreeWildcardSymbol(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "subtreeWildcard");
+	alphabet::Symbol subtreeWildcard(alib::xmlApi<alphabet::Symbol>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "subtreeWildcard");
+	return subtreeWildcard;
+}
+
+alphabet::RankedSymbol TreeFromXMLParser::parseSubtreeWildcardRankedSymbol(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "subtreeWildcard");
+	alphabet::RankedSymbol subtreeWildcard(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "subtreeWildcard");
+	return subtreeWildcard;
+}
+
+std::set<alphabet::RankedSymbol> TreeFromXMLParser::parseRankedAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<alphabet::RankedSymbol> rankedSymbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedAlphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		rankedSymbols.insert(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedAlphabet");
+	return rankedSymbols;
+}
+
+std::set<alphabet::Symbol> TreeFromXMLParser::parseAlphabet(std::deque<sax::Token>::iterator& input) {
+	std::set<alphabet::Symbol> symbols;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "alphabet");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		symbols.insert(alib::xmlApi<alphabet::Symbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "alphabet");
+	return symbols;
+}
+
+std::vector<alphabet::RankedSymbol> TreeFromXMLParser::parseContentData(std::deque<sax::Token>::iterator& input) {
+	std::vector<alphabet::RankedSymbol> data;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "content");
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		data.push_back(alib::xmlApi<alphabet::RankedSymbol>::parse(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "content");
+	return data;
+}
+
+RankedNode * TreeFromXMLParser::parseRankedNode(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "rankedNode");
+	alphabet::RankedSymbol symbol = alib::xmlApi<alphabet::RankedSymbol>::parse(input);
+	int rank = symbol.getRank().getData();
+	std::vector<RankedNode *> children;
+	children.reserve(rank);
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		children.push_back(parseRankedNode(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "rankedNode");
+
+	return new RankedNode(symbol, children);
+}
+
+UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "unrankedNode");
+	alphabet::Symbol symbol = alib::xmlApi<alphabet::Symbol>::parse(input);
+	std::vector<UnrankedNode *> children;
+	while (sax::FromXMLParserHelper::isTokenType(input, sax::Token::TokenType::START_ELEMENT)) {
+		children.push_back(parseUnrankedNode(input));
+	}
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "unrankedNode");
+
+	return new UnrankedNode(symbol, children);
+}
+
+} /* namespace tree */
+
diff --git a/alib2data/src/tree/common/TreeFromXMLParser.h b/alib2data/src/tree/common/TreeFromXMLParser.h
new file mode 100644
index 0000000000000000000000000000000000000000..73321b4b1ab5b68a63a6d25166de1b4cb36bd8fc
--- /dev/null
+++ b/alib2data/src/tree/common/TreeFromXMLParser.h
@@ -0,0 +1,43 @@
+/*
+ * TreeFromXMLParser.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#ifndef TREE_FROM_XML_PARSER_H_
+#define TREE_FROM_XML_PARSER_H_
+
+#include <set>
+#include <vector>
+#include <deque>
+
+#include "../../sax/Token.h"
+#include "../../alphabet/SymbolFeatures.h"
+#include "../ranked/RankedNode.h"
+#include "../unranked/UnrankedNode.h"
+
+namespace tree {
+
+/**
+ * Parser used to get tree from XML parsed into list of Tokens.
+ */
+class TreeFromXMLParser {
+public:
+	static RankedNode * parseRankedNode(std::deque<sax::Token>::iterator& input);
+	static std::vector<alphabet::RankedSymbol> parseContentData(std::deque<sax::Token>::iterator& input);
+	static UnrankedNode * parseUnrankedNode(std::deque<sax::Token>::iterator& input);
+	static std::set<alphabet::RankedSymbol> parseRankedAlphabet(std::deque<sax::Token>::iterator& input);
+	static std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token>::iterator& input);
+
+	static alphabet::Symbol parseBar(std::deque<sax::Token>::iterator& input);
+	static alphabet::Symbol parseVariablesBar(std::deque<sax::Token>::iterator& input);
+
+	static alphabet::Symbol parseSubtreeWildcardSymbol(std::deque<sax::Token>::iterator& input);
+	static alphabet::RankedSymbol parseSubtreeWildcardRankedSymbol(std::deque<sax::Token>::iterator& input);
+};
+
+} /* namespace tree */
+
+#endif /* TREE_FROM_XML_PARSER_H_ */
+
diff --git a/alib2data/src/tree/common/TreeToXMLComposer.cpp b/alib2data/src/tree/common/TreeToXMLComposer.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c3760cdb8c4b97d722d1a46104b1a4fc508f7457
--- /dev/null
+++ b/alib2data/src/tree/common/TreeToXMLComposer.cpp
@@ -0,0 +1,90 @@
+/*
+ * TreeToXMLComposer.cpp
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#include "TreeToXMLComposer.h"
+#include "../../XmlApi.hpp"
+
+namespace tree {
+
+void TreeToXMLComposer::composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
+	out.emplace_back(sax::Token("bar", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back(sax::Token("bar", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeVariablesBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
+	out.emplace_back(sax::Token("variablesBar", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back(sax::Token("variablesBar", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeSubtreeWildcard(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) {
+	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeSubtreeWildcard(std::deque<sax::Token>& out, const alphabet::RankedSymbol& symbol) {
+	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
+	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols) {
+	out.emplace_back(sax::Token("rankedAlphabet", sax::Token::TokenType::START_ELEMENT));
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
+	}
+	out.emplace_back(sax::Token("rankedAlphabet", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) {
+	out.emplace_back(sax::Token("alphabet", sax::Token::TokenType::START_ELEMENT));
+	for (const auto& symbol : symbols) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back(sax::Token("alphabet", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeNode(std::deque<sax::Token>& out, const RankedNode& node) {
+	out.emplace_back(sax::Token("rankedNode", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::RankedSymbol>::compose(out, node.getSymbol());
+	for(const auto& child : node.getChildren()) {
+		composeNode(out, *child);
+	}
+
+	out.emplace_back(sax::Token("rankedNode", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeNode(std::deque<sax::Token>& out, const UnrankedNode& node) {
+	out.emplace_back(sax::Token("unrankedNode", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::Symbol>::compose(out, node.getSymbol());
+	for(const auto& child : node.getChildren()) {
+		composeNode(out, *child);
+	}
+
+	out.emplace_back(sax::Token("unrankedNode", sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& content) {
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
+	for(const auto& symbol : content) {
+		alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	}
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+}
+
+void TreeToXMLComposer::composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::RankedSymbol>& content) {
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
+	for(const auto& symbol : content) {
+		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
+	}
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+}
+
+} /* namespace automaton */
+
diff --git a/alib2data/src/tree/common/TreeToXMLComposer.h b/alib2data/src/tree/common/TreeToXMLComposer.h
new file mode 100644
index 0000000000000000000000000000000000000000..aba26b4689c6a718beb3e94c727a4d96fc408dee
--- /dev/null
+++ b/alib2data/src/tree/common/TreeToXMLComposer.h
@@ -0,0 +1,45 @@
+/*
+ * TreeToXMLComposer.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#ifndef TREE_TO_XML_COMPOSER_H_
+#define TREE_TO_XML_COMPOSER_H_
+
+#include <deque>
+#include <set>
+#include <vector>
+#include "../../alphabet/SymbolFeatures.h"
+#include "../../sax/Token.h"
+#include "../ranked/RankedNode.h"
+#include "../unranked/UnrankedNode.h"
+
+namespace tree {
+
+/**
+ * This class contains methods to print XML representation of tree to the output stream.
+ */
+class TreeToXMLComposer {
+public:
+	static void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols);
+	static void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols);
+
+	static void composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
+	static void composeVariablesBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
+
+	static void composeSubtreeWildcard(std::deque<sax::Token>& out, const alphabet::Symbol& symbol);
+	static void composeSubtreeWildcard(std::deque<sax::Token>& out, const alphabet::RankedSymbol& symbol);
+
+	static void composeNode(std::deque<sax::Token>& out, const RankedNode& node);
+	static void composeNode(std::deque<sax::Token>& out, const UnrankedNode& node);
+
+	static void composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::Symbol>& content);
+	static void composeContent(std::deque<sax::Token>& out, const std::vector<alphabet::RankedSymbol>& content);
+};
+
+} /* namespace tree */
+
+#endif /* TREE_TO_XML_COMPOSER_H_ */
+
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
index ec0e59971602da759aefd2a87f89e048503d2cad..11e0c3d4c16ec357b66c94863edee23d7a031a33 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
@@ -14,6 +14,12 @@
 
 #include "RankedPattern.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::Symbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)), bar(std::move(bar)), variablesBar(std::move(variablesBar)) {
@@ -147,5 +153,33 @@ PrefixRankedBarPattern::operator std::string () const {
 	return std::move(ss).str();
 }
 
+const std::string PrefixRankedBarPattern::XML_TAG_NAME = "PrefixRankedBarPattern";
+
+PrefixRankedBarPattern PrefixRankedBarPattern::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, PrefixRankedBarPattern::XML_TAG_NAME);
+	alphabet::Symbol bar = TreeFromXMLParser::parseBar(input);
+	alphabet::Symbol variablesBarSymbol = TreeFromXMLParser::parseVariablesBar(input);
+	alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = TreeFromXMLParser::parseContentData(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, PrefixRankedBarPattern::XML_TAG_NAME);
+	return PrefixRankedBarPattern(std::move(bar), std::move(variablesBarSymbol), std::move(subtreeWildcardSymbol), std::move(rankedAlphabet), std::move(data));
+}
+
+void PrefixRankedBarPattern::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(PrefixRankedBarPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeBar(out, bar);
+	TreeToXMLComposer::composeVariablesBar(out, variablesBar);
+	TreeToXMLComposer::composeSubtreeWildcard(out, subtreeWildcard);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeContent(out, m_Data);
+	out.emplace_back(PrefixRankedBarPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
 
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedBarPattern> prefixRankedBarPatternParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedBarPattern>(tree::PrefixRankedBarPattern::XML_TAG_NAME, tree::PrefixRankedBarPattern::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index e206d861649de490b36fe011ba85e188e5244c4d..0a229ab29f535c134b27e3d2510e9499540cd30c 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -70,6 +70,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static PrefixRankedBarPattern parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
index 435bd5ed9698ab26e2084725f95dc65a498f9a43..d7560ec57028036f4689b50f1e2057b35d51c24c 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
@@ -14,6 +14,12 @@
 
 #include "RankedTree.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : bar(std::move(bar)) {
@@ -131,5 +137,29 @@ PrefixRankedBarTree::operator std::string () const {
 	return std::move(ss).str();
 }
 
+const std::string PrefixRankedBarTree::XML_TAG_NAME = "PrefixRankedBarTree";
+
+PrefixRankedBarTree PrefixRankedBarTree::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, PrefixRankedBarTree::XML_TAG_NAME);
+	alphabet::Symbol bar = TreeFromXMLParser::parseBar(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = TreeFromXMLParser::parseContentData(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, PrefixRankedBarTree::XML_TAG_NAME);
+	return PrefixRankedBarTree(std::move(bar), std::move(rankedAlphabet), std::move(data));
+}
+
+void PrefixRankedBarTree::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(PrefixRankedBarTree::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeBar(out, bar);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeContent(out, m_Data);
+	out.emplace_back(PrefixRankedBarTree::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
 
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedBarTree> prefixRankedBarTreeParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedBarTree>(tree::PrefixRankedBarTree::XML_TAG_NAME, tree::PrefixRankedBarTree::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index 0d887eac3ab5e6a9222db1af3e6d69cbbd22539f..68088760f05c0a0a4a1fed53c067e8612f0c03d5 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -67,6 +67,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static PrefixRankedBarTree parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
index 106931c551d3bb39f9b55937f6d48bbbb10fb609..36d7941905a37f5b2efd537109a484108c516d00 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
@@ -14,6 +14,12 @@
 
 #include "RankedPattern.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 PrefixRankedPattern::PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)) {
@@ -123,5 +129,29 @@ PrefixRankedPattern::operator std::string () const {
 	return std::move(ss).str();
 }
 
+const std::string PrefixRankedPattern::XML_TAG_NAME = "PrefixRankedPattern";
+
+PrefixRankedPattern PrefixRankedPattern::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, PrefixRankedPattern::XML_TAG_NAME);
+	alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = TreeFromXMLParser::parseContentData(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, PrefixRankedPattern::XML_TAG_NAME);
+	return PrefixRankedPattern(std::move(subtreeWildcardSymbol), std::move(rankedAlphabet), std::move(data));
+}
+
+void PrefixRankedPattern::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(PrefixRankedPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeSubtreeWildcard(out, subtreeWildcard);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeContent(out, m_Data);
+	out.emplace_back(PrefixRankedPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
 
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedPattern> prefixRankedPatternParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedPattern>(tree::PrefixRankedPattern::XML_TAG_NAME, tree::PrefixRankedPattern::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index 439fe5b7d5c28027fc32843b6c3dada8f200592f..56331bc755c22943ff4cc71f160837869c638f76 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -60,6 +60,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static PrefixRankedPattern parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.cpp b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
index e25bb312a97bd3b73a5832e17925562cc2d297ca..ebddab3aa893cca49e4059e418fd8898877f3a8b 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
@@ -14,6 +14,12 @@
 
 #include "RankedTree.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 PrefixRankedTree::PrefixRankedTree(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) {
@@ -120,5 +126,27 @@ PrefixRankedTree::operator std::string () const {
 	return std::move(ss).str();
 }
 
+const std::string PrefixRankedTree::XML_TAG_NAME = "PrefixRankedTree";
+
+PrefixRankedTree PrefixRankedTree::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, PrefixRankedTree::XML_TAG_NAME);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = TreeFromXMLParser::parseContentData(input);
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, PrefixRankedTree::XML_TAG_NAME);
+	return PrefixRankedTree(std::move(rankedAlphabet), std::move(data));
+}
+
+void PrefixRankedTree::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(PrefixRankedTree::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeContent(out, m_Data);
+	out.emplace_back(PrefixRankedTree::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
 
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedTree> prefixRankedTreeParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::PrefixRankedTree>(tree::PrefixRankedTree::XML_TAG_NAME, tree::PrefixRankedTree::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index f732636f0848fa9fe3b2b585aaa85b2f5801451a..e832b63b39cc704f1bde69164b996602a0ea6649 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -60,6 +60,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static PrefixRankedTree parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedPattern.cpp b/alib2data/src/tree/ranked/RankedPattern.cpp
index 7bf22b03d00122d124db26d97f6292f0d163f639..4c8bce329eb8095cd15d46f8508c0e7c2ad454de 100644
--- a/alib2data/src/tree/ranked/RankedPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedPattern.cpp
@@ -14,6 +14,12 @@
 
 #include "../unranked/UnrankedPattern.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 RankedPattern::RankedPattern(const UnrankedPattern& other) : RankedPatternAlphabet(alphabet::RankedSymbol(other.getSubtreeWildcard(), 0)) {
@@ -128,4 +134,31 @@ RankedPattern::operator std::string () const {
 	return ss.str();
 }
 
+const std::string RankedPattern::XML_TAG_NAME = "RankedPattern";
+
+RankedPattern RankedPattern::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RankedPattern::XML_TAG_NAME);
+	alphabet::RankedSymbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRankedSymbol(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	RankedNode * root = TreeFromXMLParser::parseRankedNode(input);
+	RankedPattern tree(std::move(subtreeWildcardSymbol), std::move(rankedAlphabet), std::move(*root));
+	delete root;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, RankedPattern::XML_TAG_NAME);
+	return tree;
+}
+
+void RankedPattern::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(RankedPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeSubtreeWildcard(out, subtreeWildcard);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeNode(out, *pattern);
+	out.emplace_back(RankedPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
+
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::RankedPattern> rankedPatternParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::RankedPattern>(tree::RankedPattern::XML_TAG_NAME, tree::RankedPattern::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index 8ff7744c18916fd6a6bd4aa66d5318e66677891e..fe9bb3bf83ae9c42fb5513c58e532be7a3ac7e65 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -95,6 +95,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static RankedPattern parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedTree.cpp b/alib2data/src/tree/ranked/RankedTree.cpp
index f0d69c94b18384bad0cc9a097048d304b4a03d98..bbe1975d7a1f38cb6d5fbd2b7278e21758928ea4 100644
--- a/alib2data/src/tree/ranked/RankedTree.cpp
+++ b/alib2data/src/tree/ranked/RankedTree.cpp
@@ -14,6 +14,12 @@
 
 #include "../unranked/UnrankedTree.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 RankedTree::RankedTree(const UnrankedTree& other) {
@@ -122,4 +128,29 @@ RankedTree::operator std::string () const {
 	return ss.str();
 }
 
+const std::string RankedTree::XML_TAG_NAME = "RankedTree";
+
+RankedTree RankedTree::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, RankedTree::XML_TAG_NAME);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet(input);
+	RankedNode * root = TreeFromXMLParser::parseRankedNode(input);
+	RankedTree tree(std::move(rankedAlphabet), std::move(*root));
+	delete root;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, RankedTree::XML_TAG_NAME);
+	return tree;
+}
+
+void RankedTree::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(RankedTree::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeNode(out, *tree);
+	out.emplace_back(RankedTree::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
+
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::RankedTree> rankedTreeParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::RankedTree>(tree::RankedTree::XML_TAG_NAME, tree::RankedTree::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index 1e11068c5b4680945ec630e2bf04564ac8bc4a0c..a049c41448b30b9c78a0fb996541e39c660177e3 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -95,6 +95,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static RankedTree parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.cpp b/alib2data/src/tree/unranked/UnrankedPattern.cpp
index 3dc27ddc66c81d1a77a22f2c76a881fa32f0ddb7..80a4ade2ba27d9a87badfb2275ce3962d0e0f8db 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedPattern.cpp
@@ -14,6 +14,12 @@
 
 #include "../ranked/RankedPattern.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 UnrankedPattern::UnrankedPattern(const RankedPattern& other) : UnrankedPatternAlphabet(other.getSubtreeWildcard().getSymbol()) {
@@ -128,4 +134,31 @@ UnrankedPattern::operator std::string () const {
 	return ss.str();
 }
 
+const std::string UnrankedPattern::XML_TAG_NAME = "UnrankedPattern";
+
+UnrankedPattern UnrankedPattern::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, UnrankedPattern::XML_TAG_NAME);
+	alphabet::Symbol subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardSymbol(input);
+	std::set<alphabet::Symbol> rankedAlphabet = TreeFromXMLParser::parseAlphabet(input);
+	UnrankedNode * root = TreeFromXMLParser::parseUnrankedNode(input);
+	UnrankedPattern tree(std::move(subtreeWildcardSymbol), std::move(rankedAlphabet), std::move(*root));
+	delete root;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, UnrankedPattern::XML_TAG_NAME);
+	return tree;
+}
+
+void UnrankedPattern::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(UnrankedPattern::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeSubtreeWildcard(out, subtreeWildcard);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeNode(out, *pattern);
+	out.emplace_back(UnrankedPattern::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
+
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::UnrankedPattern> unrankedPatternParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::UnrankedPattern>(tree::UnrankedPattern::XML_TAG_NAME, tree::UnrankedPattern::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 177b9cc82c3861afe90a7cf219e462e4b146a714..6180f4252e863beaefa91197d9d1404b9baa1e10 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -95,6 +95,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static UnrankedPattern parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/unranked/UnrankedTree.cpp b/alib2data/src/tree/unranked/UnrankedTree.cpp
index 3634c5fa39f82b97765f125ff6e0f296cbdb8abe..d5aa2e7a71fe64a767573d2106526dad51fd0233 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.cpp
+++ b/alib2data/src/tree/unranked/UnrankedTree.cpp
@@ -14,6 +14,12 @@
 
 #include "../ranked/RankedTree.h"
 
+#include "../../sax/FromXMLParserHelper.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../Tree.h"
+#include "../../XmlApi.hpp"
+
 namespace tree {
 
 UnrankedTree::UnrankedTree(const RankedTree& other) {
@@ -122,4 +128,29 @@ UnrankedTree::operator std::string () const {
 	return ss.str();
 }
 
+const std::string UnrankedTree::XML_TAG_NAME = "UnrankedTree";
+
+UnrankedTree UnrankedTree::parse(std::deque<sax::Token>::iterator& input) {
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, UnrankedTree::XML_TAG_NAME);
+	std::set<alphabet::Symbol> rankedAlphabet = TreeFromXMLParser::parseAlphabet(input);
+	UnrankedNode * root = TreeFromXMLParser::parseUnrankedNode(input);
+	UnrankedTree tree(std::move(rankedAlphabet), std::move(*root));
+	delete root;
+	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, UnrankedTree::XML_TAG_NAME);
+	return tree;
+}
+
+void UnrankedTree::compose(std::deque<sax::Token>& out) const {
+	out.emplace_back(UnrankedTree::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+	TreeToXMLComposer::composeAlphabet(out, alphabet);
+	TreeToXMLComposer::composeNode(out, *tree);
+	out.emplace_back(UnrankedTree::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+}
+
 } /* namespace tree */
+
+namespace alib {
+
+xmlApi<tree::Tree>::ParserRegister<tree::UnrankedTree> unrankedTreeParserRegister = xmlApi<tree::Tree>::ParserRegister<tree::UnrankedTree>(tree::UnrankedTree::XML_TAG_NAME, tree::UnrankedTree::parse);
+
+} /* namespace alib */
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index 35173add3a22d44125e4acda7985dd67232d0aea..bda48e5d98d7a7102137368a18c8d3c0fbbbdb7b 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -95,6 +95,12 @@ public:
 	virtual int selfTypeId() const {
 		return typeId(*this);
 	}
+
+	const static std::string XML_TAG_NAME;
+
+	static UnrankedTree parse(std::deque<sax::Token>::iterator& input);
+
+	void compose(std::deque<sax::Token>& out) const;
 };
 
 } /* namespace tree */