From 06a4afa4c7ff12cbc92a8aaf0f179e8c201b3ad5 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Fri, 18 Sep 2015 00:26:02 +0200
Subject: [PATCH] middle types for ranked and unranked trees

---
 alib2data/src/tree/RankedTreeBase.h           |  30 +++
 alib2data/src/tree/RankedTreeWrapper.cpp      |  16 ++
 alib2data/src/tree/RankedTreeWrapper.h        |  29 +++
 alib2data/src/tree/Tree.h                     |   7 +-
 alib2data/src/tree/UnrankedTreeBase.h         |  30 +++
 alib2data/src/tree/UnrankedTreeWrapper.cpp    |  16 ++
 alib2data/src/tree/UnrankedTreeWrapper.h      |  29 +++
 .../tree/ranked/PrefixRankedBarPattern.cpp    | 181 ++++++++++--------
 .../src/tree/ranked/PrefixRankedBarPattern.h  |  12 +-
 .../src/tree/ranked/PrefixRankedBarTree.cpp   | 155 ++++++++-------
 .../src/tree/ranked/PrefixRankedBarTree.h     |  12 +-
 .../src/tree/ranked/PrefixRankedPattern.cpp   | 160 +++++++++-------
 .../src/tree/ranked/PrefixRankedPattern.h     |  12 +-
 .../src/tree/ranked/PrefixRankedTree.cpp      | 152 ++++++++-------
 alib2data/src/tree/ranked/PrefixRankedTree.h  |  12 +-
 alib2data/src/tree/ranked/RankedPattern.cpp   | 153 ++++++++-------
 alib2data/src/tree/ranked/RankedPattern.h     |  12 +-
 alib2data/src/tree/ranked/RankedTree.cpp      | 138 ++++++-------
 alib2data/src/tree/ranked/RankedTree.h        |  12 +-
 .../src/tree/unranked/UnrankedPattern.cpp     | 153 ++++++++-------
 alib2data/src/tree/unranked/UnrankedPattern.h |  12 +-
 alib2data/src/tree/unranked/UnrankedTree.cpp  | 138 ++++++-------
 alib2data/src/tree/unranked/UnrankedTree.h    |  12 +-
 23 files changed, 868 insertions(+), 615 deletions(-)
 create mode 100644 alib2data/src/tree/RankedTreeBase.h
 create mode 100644 alib2data/src/tree/RankedTreeWrapper.cpp
 create mode 100644 alib2data/src/tree/RankedTreeWrapper.h
 create mode 100644 alib2data/src/tree/UnrankedTreeBase.h
 create mode 100644 alib2data/src/tree/UnrankedTreeWrapper.cpp
 create mode 100644 alib2data/src/tree/UnrankedTreeWrapper.h

diff --git a/alib2data/src/tree/RankedTreeBase.h b/alib2data/src/tree/RankedTreeBase.h
new file mode 100644
index 0000000000..783522d83a
--- /dev/null
+++ b/alib2data/src/tree/RankedTreeBase.h
@@ -0,0 +1,30 @@
+/*
+ * TreeBase.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#ifndef RANKED_TREE_BASE_H_
+#define RANKED_TREE_BASE_H_
+
+#include "TreeBase.h"
+#include <set>
+#include "../alphabet/RankedSymbol.h"
+
+namespace tree {
+
+/**
+ * Represents symbol in an alphabet.
+ */
+class RankedTreeBase : public tree::TreeBase {
+public:
+	virtual RankedTreeBase * clone ( ) const = 0;
+	virtual RankedTreeBase * plunder ( ) &&	 = 0;
+
+	virtual const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const = 0;
+};
+
+} /* namespace tree */
+
+#endif /* RANKED_TREE_BASE_H_ */
diff --git a/alib2data/src/tree/RankedTreeWrapper.cpp b/alib2data/src/tree/RankedTreeWrapper.cpp
new file mode 100644
index 0000000000..5ac4882a9e
--- /dev/null
+++ b/alib2data/src/tree/RankedTreeWrapper.cpp
@@ -0,0 +1,16 @@
+/*
+ * RankedTreeWrapper.cpp
+ *
+ *  Created on: Apr 16, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "RankedTreeWrapper.h"
+
+namespace tree {
+
+const std::set < alphabet::RankedSymbol > & RankedTreeWrapper::getAlphabet ( ) const {
+	return this->getData ( ).getAlphabet ( );
+}
+
+} /* namespace tree */
diff --git a/alib2data/src/tree/RankedTreeWrapper.h b/alib2data/src/tree/RankedTreeWrapper.h
new file mode 100644
index 0000000000..393c16f969
--- /dev/null
+++ b/alib2data/src/tree/RankedTreeWrapper.h
@@ -0,0 +1,29 @@
+/*
+ * RankedTreeWrapper.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Stepan Plachy
+ */
+
+#ifndef RANKED_TREE_WRAPPER_H_
+#define RANKED_TREE_WRAPPER_H_
+
+#include "../object/WrapperBase.h"
+#include "RankedTreeBase.h"
+#include "../common/wrapper.hpp"
+
+namespace tree {
+
+/**
+ * Wrapper around tree.
+ */
+class RankedTreeWrapper : public alib::wrapper < RankedTreeBase >, public alib::WrapperBase {
+	using alib::wrapper < RankedTreeBase >::wrapper;
+
+public:
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const;
+};
+
+} /* namespace tree */
+
+#endif /* RANKED_TREE_WRAPPER_H- */
diff --git a/alib2data/src/tree/Tree.h b/alib2data/src/tree/Tree.h
index 02dec346e5..5ac39b5768 100644
--- a/alib2data/src/tree/Tree.h
+++ b/alib2data/src/tree/Tree.h
@@ -17,11 +17,10 @@ namespace tree {
 /**
  * Wrapper around tree.
  */
-class Tree : public alib::wrapper<TreeBase>, public alib::WrapperBase {
-	using alib::wrapper<TreeBase>::wrapper;
+class Tree : public alib::wrapper < TreeBase >, public alib::WrapperBase {
+	using alib::wrapper < TreeBase >::wrapper;
 };
 
 } /* namespace tree */
 
-#endif /* Tree_H_ */
-
+#endif /* TREE_H_ */
diff --git a/alib2data/src/tree/UnrankedTreeBase.h b/alib2data/src/tree/UnrankedTreeBase.h
new file mode 100644
index 0000000000..42f1586b80
--- /dev/null
+++ b/alib2data/src/tree/UnrankedTreeBase.h
@@ -0,0 +1,30 @@
+/*
+ * TreeBase.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Jan Tranicek
+ */
+
+#ifndef UNRANKED_TREE_BASE_H_
+#define UNRANKED_TREE_BASE_H_
+
+#include "TreeBase.h"
+#include <set>
+#include "../alphabet/Symbol.h"
+
+namespace tree {
+
+/**
+ * Represents symbol in an alphabet.
+ */
+class UnrankedTreeBase : public TreeBase {
+public:
+	virtual UnrankedTreeBase * clone ( ) const = 0;
+	virtual UnrankedTreeBase * plunder ( ) &&  = 0;
+
+	virtual const std::set < alphabet::Symbol > & getAlphabet ( ) const = 0;
+};
+
+} /* namespace tree */
+
+#endif /* UNRANKED_TREE_BASE_H_ */
diff --git a/alib2data/src/tree/UnrankedTreeWrapper.cpp b/alib2data/src/tree/UnrankedTreeWrapper.cpp
new file mode 100644
index 0000000000..842d460186
--- /dev/null
+++ b/alib2data/src/tree/UnrankedTreeWrapper.cpp
@@ -0,0 +1,16 @@
+/*
+ * UnrankedTreeWrapper.cpp
+ *
+ *  Created on: Apr 16, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "UnrankedTreeWrapper.h"
+
+namespace tree {
+
+const std::set < alphabet::Symbol > & UnrankedTreeWrapper::getAlphabet ( ) const {
+	return this->getData ( ).getAlphabet ( );
+}
+
+} /* namespace tree */
diff --git a/alib2data/src/tree/UnrankedTreeWrapper.h b/alib2data/src/tree/UnrankedTreeWrapper.h
new file mode 100644
index 0000000000..4b22c56a25
--- /dev/null
+++ b/alib2data/src/tree/UnrankedTreeWrapper.h
@@ -0,0 +1,29 @@
+/*
+ * UnrankedTreeWrapper.h
+ *
+ *  Created on: Nov 16, 2014
+ *      Author: Jan Travnicek
+ */
+
+#ifndef UNRANKED_TREE_WRAPPER_H_
+#define UNRANKED_TREE_WRAPPER_H_
+
+#include "../object/WrapperBase.h"
+#include "UnrankedTreeBase.h"
+#include "../common/wrapper.hpp"
+
+namespace tree {
+
+/**
+ * Wrapper around tree.
+ */
+class UnrankedTreeWrapper : public alib::wrapper < UnrankedTreeBase >, public alib::WrapperBase {
+	using alib::wrapper < UnrankedTreeBase >::wrapper;
+
+public:
+	const std::set < alphabet::Symbol > & getAlphabet ( ) const;
+};
+
+} /* namespace tree */
+
+#endif /* UNRANKED_TREE_WRAPPER_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
index 982c8e68f0..a689907aed 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
@@ -23,165 +23,178 @@
 
 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)) {
-	this->alphabet = std::move(alphabet);
-	setContent(std::move(data));
+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 ) ) {
+	this->alphabet = std::move ( alphabet );
+	setContent ( std::move ( data ) );
 }
 
-PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::Symbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)), bar(std::move(bar)), variablesBar(std::move(variablesBar)) {
-	arityChecksum(data);
+PrefixRankedBarPattern::PrefixRankedBarPattern ( alphabet::Symbol bar, alphabet::Symbol variablesBar, alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ), bar ( std::move ( bar ) ), variablesBar ( std::move ( variablesBar ) ) {
+	arityChecksum ( data );
 
-	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
-	m_Data = std::move(data);
+	alphabet = std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) );
+	m_Data = std::move ( data );
 }
 
-PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::Symbol variablesBar, const RankedPattern& tree) : RankedPatternAlphabet(tree.getSubtreeWildcard()), bar(std::move(bar)), variablesBar(std::move(variablesBar)) {
-	toPrefixRankedBar(tree.getRoot());
-	alphabet = std::set<alphabet::RankedSymbol>(m_Data.begin(), m_Data.end());
+PrefixRankedBarPattern::PrefixRankedBarPattern ( alphabet::Symbol bar, alphabet::Symbol variablesBar, const RankedPattern & tree ) : RankedPatternAlphabet ( tree.getSubtreeWildcard ( ) ), bar ( std::move ( bar ) ), variablesBar ( std::move ( variablesBar ) ) {
+	toPrefixRankedBar ( tree.getRoot ( ) );
+	alphabet = std::set < alphabet::RankedSymbol > ( m_Data.begin ( ), m_Data.end ( ) );
 }
 
-void PrefixRankedBarPattern::toPrefixRankedBar(const RankedNode& node) {
-	if(node.getSymbol() == subtreeWildcard) {
-		m_Data.push_back(node.getSymbol());
-		m_Data.push_back(alphabet::RankedSymbol(variablesBar, node.getSymbol().getRank()));
+void PrefixRankedBarPattern::toPrefixRankedBar ( const RankedNode & node ) {
+	if ( node.getSymbol ( ) == subtreeWildcard ) {
+		m_Data.push_back ( node.getSymbol ( ) );
+		m_Data.push_back ( alphabet::RankedSymbol ( variablesBar, node.getSymbol ( ).getRank ( ) ) );
 	} else {
-		m_Data.push_back(node.getSymbol());
-		for(const RankedNode* child : node.getChildren())
-			toPrefixRankedBar(*child);
-		m_Data.push_back(alphabet::RankedSymbol(bar, node.getSymbol().getRank()));
+		m_Data.push_back ( node.getSymbol ( ) );
+
+		for ( const RankedNode * child : node.getChildren ( ) )
+			toPrefixRankedBar ( * child );
+
+		m_Data.push_back ( alphabet::RankedSymbol ( bar, node.getSymbol ( ).getRank ( ) ) );
 	}
 }
 
-TreeBase* PrefixRankedBarPattern::clone() const {
-	return new PrefixRankedBarPattern(*this);
+RankedTreeBase * PrefixRankedBarPattern::clone ( ) const {
+	return new PrefixRankedBarPattern ( * this );
 }
 
-TreeBase* PrefixRankedBarPattern::plunder() && {
-	return new PrefixRankedBarPattern(std::move(*this));
+RankedTreeBase * PrefixRankedBarPattern::plunder ( ) && {
+	return new PrefixRankedBarPattern ( std::move ( * this ) );
 }
 
-bool PrefixRankedBarPattern::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool PrefixRankedBarPattern::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( std::any_of ( m_Data.begin ( ), m_Data.end ( ), [&] ( const alphabet::RankedSymbol & s ) {
+			return s == symbol;
+		} ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	if(this->subtreeWildcard == symbol)
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtreeWildcard.");
+	if ( this->subtreeWildcard == symbol )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is subtreeWildcard." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-const std::vector<alphabet::RankedSymbol>& PrefixRankedBarPattern::getContent() const {
+const std::vector < alphabet::RankedSymbol > & PrefixRankedBarPattern::getContent ( ) const {
 	return this->m_Data;
 }
 
-void PrefixRankedBarPattern::setContent(std::vector<alphabet::RankedSymbol> data) {
-	arityChecksum(data);
+void PrefixRankedBarPattern::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
 
-	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
-	std::set<alphabet::RankedSymbol> unknownSymbols;
-	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), alphabet.begin ( ), alphabet.end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
 
-	if(unknownSymbols.size() > 0)
-		throw exception::AlibException("Input symbols not in the alphabet.");
+	if ( unknownSymbols.size ( ) > 0 )
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 
-	this->m_Data = std::move(data);
+	this->m_Data = std::move ( data );
 }
 
-const alphabet::Symbol& PrefixRankedBarPattern::getBarSymbol() const {
+const alphabet::Symbol & PrefixRankedBarPattern::getBarSymbol ( ) const {
 	return bar;
 }
 
-const alphabet::Symbol& PrefixRankedBarPattern::getVariablesBarSymbol() const {
+const alphabet::Symbol & PrefixRankedBarPattern::getVariablesBarSymbol ( ) const {
 	return variablesBar;
 }
 
-void PrefixRankedBarPattern::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+void PrefixRankedBarPattern::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
 	int arityChecksumTerminals = 1;
-	int arityChecksumBars = 1;
+	int arityChecksumBars  = 1;
 	int arityChecksumTypes = 0;
-	for(const alphabet::RankedSymbol& symbol : data) {
-		if(symbol.getSymbol() != bar && symbol.getSymbol() != variablesBar) {
-			arityChecksumTerminals += symbol.getRank().getData();
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		if ( ( symbol.getSymbol ( ) != bar ) && ( symbol.getSymbol ( ) != variablesBar ) ) {
+			arityChecksumTerminals += symbol.getRank ( ).getData ( );
 			arityChecksumTerminals -= 1;
 			arityChecksumTypes += 1;
 		} else {
-			arityChecksumBars += symbol.getRank().getData();
-			arityChecksumBars -= 1;
+			arityChecksumBars  += symbol.getRank ( ).getData ( );
+			arityChecksumBars  -= 1;
 			arityChecksumTypes -= 1;
 		}
 	}
 
-	if(arityChecksumTerminals != 0 || arityChecksumBars != 0 || arityChecksumTypes != 0) throw exception::AlibException("The string does not form a tree");
+	if ( ( arityChecksumTerminals != 0 ) || ( arityChecksumBars != 0 ) || ( arityChecksumTypes != 0 ) ) throw exception::AlibException ( "The string does not form a tree" );
+
+	for ( unsigned i = 0; i < data.size ( ); ++i )
+		if ( ( data[i] == subtreeWildcard ) && ( ( ( i + 1 ) == data.size ( ) ) || ( data[i + 1].getSymbol ( ) != variablesBar ) ) ) throw exception::AlibException ( "Inconsystency of SubtreeWildcard and variablesBar" );
 
-	for(unsigned i = 0; i < data.size(); ++i) {
-		if(data[i] == subtreeWildcard && ((i + 1) == data.size() || data[i + 1].getSymbol() != variablesBar)) throw exception::AlibException("Inconsystency of SubtreeWildcard and variablesBar");
-	}
 }
 
-bool PrefixRankedBarPattern::isEmpty() const {
-	return this->m_Data.size() == 0;
+bool PrefixRankedBarPattern::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
 }
 
-int PrefixRankedBarPattern::compare(const PrefixRankedBarPattern& other) const {
-	auto first = std::tie(m_Data, alphabet);
-	auto second = std::tie(other.m_Data, other.alphabet);
+int PrefixRankedBarPattern::compare ( const PrefixRankedBarPattern & other ) const {
+	auto first	= std::tie ( m_Data, alphabet );
+	auto second = std::tie ( other.m_Data, other.alphabet );
+
+	std::compare < decltype ( first ) > comp;
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	return comp ( first, second );
 }
 
-void PrefixRankedBarPattern::operator >>(std::ostream& out) const {
-	if( this->isEmpty() ) {
+void PrefixRankedBarPattern::operator >>( std::ostream & out ) const {
+	if ( this->isEmpty ( ) ) {
 		out << "(Epsilon)";
 	} else {
 		out << "(PrefixRankedBarPattern ";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
 			out << symbol;
+
 		out << ")";
 	}
 }
 
-PrefixRankedBarPattern::operator std::string () const {
+PrefixRankedBarPattern::operator std::string ( ) const {
 	std::stringstream ss;
-	if( this->isEmpty() ) {
+
+	if ( this->isEmpty ( ) ) {
 		ss << "E";
 	} else {
 		ss << "\"";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
-			ss << (std::string) symbol;
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+			ss << ( std::string ) symbol;
+
 		ss << "\"";
 	}
-	return std::move(ss).str();
+
+	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));
+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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedBarPattern> prefixRankedBarPatternParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedBarPattern>(tree::PrefixRankedBarPattern::XML_TAG_NAME, tree::PrefixRankedBarPattern::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarPattern > prefixRankedBarPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarPattern > ( tree::PrefixRankedBarPattern::XML_TAG_NAME, tree::PrefixRankedBarPattern::parse );
+xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedBarPattern > prefixRankedBarPatternParserRegister2 = xmlApi < alib::Object >::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 41e0d973f7..6a5116cace 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "../../alphabet/RankedSymbol.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedPatternAlphabet.h"
 #include "RankedNode.h"
 
@@ -24,7 +24,7 @@ class RankedPattern;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedBarPattern : public TreeBase, public RankedPatternAlphabet {
+class PrefixRankedBarPattern : public RankedTreeBase, public RankedPatternAlphabet {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	alphabet::Symbol bar;
@@ -37,8 +37,8 @@ public:
 
 	void toPrefixRankedBar ( const RankedNode & node );
 
-	virtual TreeBase * clone ( ) const;
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	virtual bool removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol );
 
@@ -47,6 +47,10 @@ public:
 	 */
 	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedPatternAlphabet::getAlphabet ( );
+	}
+
 	void setContent ( std::vector < alphabet::RankedSymbol > data );
 
 	const alphabet::Symbol & getBarSymbol ( ) const;
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
index 24c222286b..6a69b672ad 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
@@ -23,145 +23,158 @@
 
 namespace tree {
 
-PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : bar(std::move(bar)) {
-	this->alphabet = std::move(alphabet);
-	setContent(std::move(data));
+PrefixRankedBarTree::PrefixRankedBarTree ( alphabet::Symbol bar, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : bar ( std::move ( bar ) ) {
+	this->alphabet = std::move ( alphabet );
+	setContent ( std::move ( data ) );
 }
 
-PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, std::vector<alphabet::RankedSymbol> data) : bar(std::move(bar)) {
-	arityChecksum(data);
+PrefixRankedBarTree::PrefixRankedBarTree ( alphabet::Symbol bar, std::vector < alphabet::RankedSymbol > data ) : bar ( std::move ( bar ) ) {
+	arityChecksum ( data );
 
-	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
-	m_Data = std::move(data);
+	alphabet = std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) );
+	m_Data = std::move ( data );
 }
 
-PrefixRankedBarTree::PrefixRankedBarTree(alphabet::Symbol bar, const RankedTree& tree) : bar(std::move(bar)) {
-	toPrefixRankedBar(tree.getRoot());
-	alphabet = std::set<alphabet::RankedSymbol>(m_Data.begin(), m_Data.end());
+PrefixRankedBarTree::PrefixRankedBarTree ( alphabet::Symbol bar, const RankedTree & tree ) : bar ( std::move ( bar ) ) {
+	toPrefixRankedBar ( tree.getRoot ( ) );
+	alphabet = std::set < alphabet::RankedSymbol > ( m_Data.begin ( ), m_Data.end ( ) );
 }
 
-void PrefixRankedBarTree::toPrefixRankedBar(const RankedNode& node) {
-	m_Data.push_back(node.getSymbol());
-	for(const RankedNode* child : node.getChildren())
-		toPrefixRankedBar(*child);
-	m_Data.push_back(alphabet::RankedSymbol(bar, node.getSymbol().getRank()));
+void PrefixRankedBarTree::toPrefixRankedBar ( const RankedNode & node ) {
+	m_Data.push_back ( node.getSymbol ( ) );
+
+	for ( const RankedNode * child : node.getChildren ( ) )
+		toPrefixRankedBar ( * child );
+
+	m_Data.push_back ( alphabet::RankedSymbol ( bar, node.getSymbol ( ).getRank ( ) ) );
 }
 
-TreeBase* PrefixRankedBarTree::clone() const {
-	return new PrefixRankedBarTree(*this);
+RankedTreeBase * PrefixRankedBarTree::clone ( ) const {
+	return new PrefixRankedBarTree ( * this );
 }
 
-TreeBase* PrefixRankedBarTree::plunder() && {
-	return new PrefixRankedBarTree(std::move(*this));
+RankedTreeBase * PrefixRankedBarTree::plunder ( ) && {
+	return new PrefixRankedBarTree ( std::move ( * this ) );
 }
 
-bool PrefixRankedBarTree::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool PrefixRankedBarTree::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( std::any_of ( m_Data.begin ( ), m_Data.end ( ), [&] ( const alphabet::RankedSymbol & s ) {
+			return s == symbol;
+		} ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-const std::vector<alphabet::RankedSymbol>& PrefixRankedBarTree::getContent() const {
+const std::vector < alphabet::RankedSymbol > & PrefixRankedBarTree::getContent ( ) const {
 	return this->m_Data;
 }
 
-const alphabet::Symbol& PrefixRankedBarTree::getBarSymbol() const {
+const alphabet::Symbol & PrefixRankedBarTree::getBarSymbol ( ) const {
 	return bar;
 }
 
-void PrefixRankedBarTree::setContent(std::vector<alphabet::RankedSymbol> data) {
-	arityChecksum(data);
+void PrefixRankedBarTree::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
 
-	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
-	std::set<alphabet::RankedSymbol> unknownSymbols;
-	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), alphabet.begin ( ), alphabet.end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
 
-	if(unknownSymbols.size() > 0)
-		throw exception::AlibException("Input symbols not in the alphabet.");
+	if ( unknownSymbols.size ( ) > 0 )
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 
-	this->m_Data = std::move(data);
+	this->m_Data = std::move ( data );
 }
 
-void PrefixRankedBarTree::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+void PrefixRankedBarTree::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
 	int arityChecksumTerminals = 1;
-	int arityChecksumBars = 1;
+	int arityChecksumBars  = 1;
 	int arityChecksumTypes = 0;
-	for(const alphabet::RankedSymbol& symbol : data) {
-		if(symbol.getSymbol() != bar) {
-			arityChecksumTerminals += symbol.getRank().getData();
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		if ( symbol.getSymbol ( ) != bar ) {
+			arityChecksumTerminals += symbol.getRank ( ).getData ( );
 			arityChecksumTerminals -= 1;
 			arityChecksumTypes += 1;
 		} else {
-			arityChecksumBars += symbol.getRank().getData();
-			arityChecksumBars -= 1;
+			arityChecksumBars  += symbol.getRank ( ).getData ( );
+			arityChecksumBars  -= 1;
 			arityChecksumTypes -= 1;
 		}
 	}
 
-	if(arityChecksumTerminals != 0 || arityChecksumBars != 0 || arityChecksumTypes != 0) throw exception::AlibException("The string does not form a tree");
+	if ( ( arityChecksumTerminals != 0 ) || ( arityChecksumBars != 0 ) || ( arityChecksumTypes != 0 ) ) throw exception::AlibException ( "The string does not form a tree" );
 }
 
-bool PrefixRankedBarTree::isEmpty() const {
-	return this->m_Data.size() == 0;
+bool PrefixRankedBarTree::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
 }
 
-int PrefixRankedBarTree::compare(const PrefixRankedBarTree& other) const {
-	auto first = std::tie(m_Data, alphabet);
-	auto second = std::tie(other.m_Data, other.alphabet);
+int PrefixRankedBarTree::compare ( const PrefixRankedBarTree & other ) const {
+	auto first	= std::tie ( m_Data, alphabet );
+	auto second = std::tie ( other.m_Data, other.alphabet );
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
 }
 
-void PrefixRankedBarTree::operator >>(std::ostream& out) const {
-	if( this->isEmpty() ) {
+void PrefixRankedBarTree::operator >>( std::ostream & out ) const {
+	if ( this->isEmpty ( ) ) {
 		out << "(Epsilon)";
 	} else {
 		out << "(PrefixRankedBarTree ";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
 			out << symbol;
+
 		out << ")";
 	}
 }
 
-PrefixRankedBarTree::operator std::string () const {
+PrefixRankedBarTree::operator std::string ( ) const {
 	std::stringstream ss;
-	if( this->isEmpty() ) {
+
+	if ( this->isEmpty ( ) ) {
 		ss << "E";
 	} else {
 		ss << "\"";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
-			ss << (std::string) symbol;
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+			ss << ( std::string ) symbol;
+
 		ss << "\"";
 	}
-	return std::move(ss).str();
+
+	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));
+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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedBarTree> prefixRankedBarTreeParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedBarTree>(tree::PrefixRankedBarTree::XML_TAG_NAME, tree::PrefixRankedBarTree::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarTree > prefixRankedBarTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarTree > ( tree::PrefixRankedBarTree::XML_TAG_NAME, tree::PrefixRankedBarTree::parse );
+xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedBarTree > prefixRankedBarTreeParserRegister2 = xmlApi < alib::Object >::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 8315b1add1..564a4c4bfd 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "../../alphabet/RankedSymbol.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedAlphabet.h"
 #include "RankedNode.h"
 
@@ -24,7 +24,7 @@ class RankedTree;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedBarTree : public TreeBase, public RankedAlphabet {
+class PrefixRankedBarTree : public RankedTreeBase, public RankedAlphabet {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	alphabet::Symbol bar;
@@ -36,8 +36,8 @@ public:
 
 	void toPrefixRankedBar ( const RankedNode & node );
 
-	virtual TreeBase * clone ( ) const;
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	virtual bool removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol );
 
@@ -46,6 +46,10 @@ public:
 	 */
 	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedAlphabet::getAlphabet ( );
+	}
+
 	const alphabet::Symbol & getBarSymbol ( ) const;
 
 	void setContent ( std::vector < alphabet::RankedSymbol > data );
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
index 7234234895..2df24d5258 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
@@ -24,140 +24,154 @@
 
 namespace tree {
 
-PrefixRankedPattern::PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)) {
-	this->alphabet = std::move(alphabet);
-	setContent(std::move(data));
+PrefixRankedPattern::PrefixRankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	this->alphabet = std::move ( alphabet );
+	setContent ( std::move ( data ) );
 }
 
-PrefixRankedPattern::PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)) {
-	arityChecksum(data);
+PrefixRankedPattern::PrefixRankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	arityChecksum ( data );
 
-	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
-	m_Data = std::move(data);
+	alphabet = std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) );
+	m_Data = std::move ( data );
 }
 
-PrefixRankedPattern::PrefixRankedPattern(const RankedPattern& tree) : RankedPatternAlphabet(tree.getSubtreeWildcard()) {
-	alphabet = tree.getAlphabet();
-	std::deque<const RankedNode*> queue {&tree.getRoot()};
-	while(!queue.empty()) {
-		const RankedNode* elem = queue.back();
-		queue.pop_back();
-
-		m_Data.push_back(elem->getSymbol());
-		for(const RankedNode* child : elem->getChildren()) {
-			queue.push_back(child);
-		}
+PrefixRankedPattern::PrefixRankedPattern ( const RankedPattern & tree ) : RankedPatternAlphabet ( tree.getSubtreeWildcard ( ) ) {
+	alphabet = tree.getAlphabet ( );
+	std::deque < const RankedNode * > queue {
+		& tree.getRoot ( )
+	};
+
+	while ( !queue.empty ( ) ) {
+		const RankedNode * elem = queue.back ( );
+		queue.pop_back ( );
+
+		m_Data.push_back ( elem->getSymbol ( ) );
+
+		for ( const RankedNode * child : elem->getChildren ( ) )
+			queue.push_back ( child );
 	}
 }
 
-TreeBase* PrefixRankedPattern::clone() const {
-	return new PrefixRankedPattern(*this);
+RankedTreeBase * PrefixRankedPattern::clone ( ) const {
+	return new PrefixRankedPattern ( * this );
 }
 
-TreeBase* PrefixRankedPattern::plunder() && {
-	return new PrefixRankedPattern(std::move(*this));
+RankedTreeBase * PrefixRankedPattern::plunder ( ) && {
+	return new PrefixRankedPattern ( std::move ( * this ) );
 }
 
-bool PrefixRankedPattern::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool PrefixRankedPattern::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( std::any_of ( m_Data.begin ( ), m_Data.end ( ), [&] ( const alphabet::RankedSymbol & s ) {
+			return s == symbol;
+		} ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	if(this->subtreeWildcard == symbol)
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtreeWildcard.");
+	if ( this->subtreeWildcard == symbol )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is subtreeWildcard." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-const std::vector<alphabet::RankedSymbol>& PrefixRankedPattern::getContent() const {
+const std::vector < alphabet::RankedSymbol > & PrefixRankedPattern::getContent ( ) const {
 	return this->m_Data;
 }
 
-void PrefixRankedPattern::setContent(std::vector<alphabet::RankedSymbol> data) {
-	arityChecksum(data);
+void PrefixRankedPattern::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
 
-	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
-	std::set<alphabet::RankedSymbol> unknownSymbols;
-	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), alphabet.begin ( ), alphabet.end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
 
-	if(unknownSymbols.size() > 0)
-		throw exception::AlibException("Input symbols not in the alphabet.");
+	if ( unknownSymbols.size ( ) > 0 )
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 
-	this->m_Data = std::move(data);
+	this->m_Data = std::move ( data );
 }
 
-void PrefixRankedPattern::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+void PrefixRankedPattern::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
 	int arityChecksum = 1;
-	for(const alphabet::RankedSymbol& symbol : data) {
-		arityChecksum += symbol.getRank().getData();
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		arityChecksum += symbol.getRank ( ).getData ( );
 		arityChecksum -= 1;
 	}
 
-	if(arityChecksum != 0) throw exception::AlibException("The string does not form a tree");
+	if ( arityChecksum != 0 ) throw exception::AlibException ( "The string does not form a tree" );
 }
 
-bool PrefixRankedPattern::isEmpty() const {
-	return this->m_Data.size() == 0;
+bool PrefixRankedPattern::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
 }
 
-int PrefixRankedPattern::compare(const PrefixRankedPattern& other) const {
-	auto first = std::tie(m_Data, alphabet);
-	auto second = std::tie(other.m_Data, other.alphabet);
+int PrefixRankedPattern::compare ( const PrefixRankedPattern & other ) const {
+	auto first	= std::tie ( m_Data, alphabet );
+	auto second = std::tie ( other.m_Data, other.alphabet );
+
+	std::compare < decltype ( first ) > comp;
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	return comp ( first, second );
 }
 
-void PrefixRankedPattern::operator >>(std::ostream& out) const {
-	if( this->isEmpty() ) {
+void PrefixRankedPattern::operator >>( std::ostream & out ) const {
+	if ( this->isEmpty ( ) ) {
 		out << "(Epsilon)";
 	} else {
 		out << "(PrefixRankedPattern ";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
 			out << symbol;
+
 		out << ")";
 	}
 }
 
-PrefixRankedPattern::operator std::string () const {
+PrefixRankedPattern::operator std::string ( ) const {
 	std::stringstream ss;
-	if( this->isEmpty() ) {
+
+	if ( this->isEmpty ( ) ) {
 		ss << "E";
 	} else {
 		ss << "\"";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
-			ss << (std::string) symbol;
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+			ss << ( std::string ) symbol;
+
 		ss << "\"";
 	}
-	return std::move(ss).str();
+
+	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));
+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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedPattern> prefixRankedPatternParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedPattern>(tree::PrefixRankedPattern::XML_TAG_NAME, tree::PrefixRankedPattern::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedPattern > prefixRankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedPattern > ( tree::PrefixRankedPattern::XML_TAG_NAME, tree::PrefixRankedPattern::parse );
+xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedPattern > prefixRankedPatternParserRegister2 = xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedPattern > ( tree::PrefixRankedPattern::XML_TAG_NAME, tree::PrefixRankedPattern::parse );
 
-auto PrefixRankedPatternFromRankedPattern = castApi::CastRegister<tree::PrefixRankedPattern, tree::RankedPattern>();
-auto PrefixRankedPatternCastBinder = castApi::CastPoolStringBinder<tree::PrefixRankedPattern>(tree::PrefixRankedPattern::XML_TAG_NAME);
+auto PrefixRankedPatternFromRankedPattern = castApi::CastRegister < tree::PrefixRankedPattern, tree::RankedPattern > ( );
+auto PrefixRankedPatternCastBinder = castApi::CastPoolStringBinder < tree::PrefixRankedPattern > ( tree::PrefixRankedPattern::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index 2173003d09..02b9e56e59 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "../../alphabet/RankedSymbol.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedPatternAlphabet.h"
 
 namespace tree {
@@ -23,7 +23,7 @@ class RankedPattern;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedPattern : public TreeBase, public RankedPatternAlphabet {
+class PrefixRankedPattern : public RankedTreeBase, public RankedPatternAlphabet {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 public:
@@ -31,8 +31,8 @@ public:
 	explicit PrefixRankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::vector < alphabet::RankedSymbol > data );
 	explicit PrefixRankedPattern ( const RankedPattern & tree );
 
-	virtual TreeBase * clone ( ) const;
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	virtual bool removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol );
 
@@ -41,6 +41,10 @@ public:
 	 */
 	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedPatternAlphabet::getAlphabet ( );
+	}
+
 	void setContent ( std::vector < alphabet::RankedSymbol > data );
 
 	void arityChecksum ( const std::vector < alphabet::RankedSymbol > & data );
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.cpp b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
index eb98239f6c..ac012e367f 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
@@ -24,135 +24,149 @@
 
 namespace tree {
 
-PrefixRankedTree::PrefixRankedTree(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) {
-	this->alphabet = std::move(alphabet);
-	setContent(std::move(data));
+PrefixRankedTree::PrefixRankedTree ( std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) {
+	this->alphabet = std::move ( alphabet );
+	setContent ( std::move ( data ) );
 }
 
-PrefixRankedTree::PrefixRankedTree(std::vector<alphabet::RankedSymbol> data) {
-	arityChecksum(data);
+PrefixRankedTree::PrefixRankedTree ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
 
-	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
-	m_Data = std::move(data);
+	alphabet = std::set < alphabet::RankedSymbol > ( data.begin ( ), data.end ( ) );
+	m_Data = std::move ( data );
 }
 
-PrefixRankedTree::PrefixRankedTree(const RankedTree& tree) {
-	alphabet = tree.getAlphabet();
-	std::deque<const RankedNode*> queue {&tree.getRoot()};
-	while(!queue.empty()) {
-		const RankedNode* elem = queue.back();
-		queue.pop_back();
-
-		m_Data.push_back(elem->getSymbol());
-		for(const RankedNode* child : elem->getChildren()) {
-			queue.push_back(child);
-		}
+PrefixRankedTree::PrefixRankedTree ( const RankedTree & tree ) {
+	alphabet = tree.getAlphabet ( );
+	std::deque < const RankedNode * > queue {
+		& tree.getRoot ( )
+	};
+
+	while ( !queue.empty ( ) ) {
+		const RankedNode * elem = queue.back ( );
+		queue.pop_back ( );
+
+		m_Data.push_back ( elem->getSymbol ( ) );
+
+		for ( const RankedNode * child : elem->getChildren ( ) )
+			queue.push_back ( child );
 	}
 }
 
-TreeBase* PrefixRankedTree::clone() const {
-	return new PrefixRankedTree(*this);
+RankedTreeBase * PrefixRankedTree::clone ( ) const {
+	return new PrefixRankedTree ( * this );
 }
 
-TreeBase* PrefixRankedTree::plunder() && {
-	return new PrefixRankedTree(std::move(*this));
+RankedTreeBase * PrefixRankedTree::plunder ( ) && {
+	return new PrefixRankedTree ( std::move ( * this ) );
 }
 
-bool PrefixRankedTree::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool PrefixRankedTree::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( std::any_of ( m_Data.begin ( ), m_Data.end ( ), [&] ( const alphabet::RankedSymbol & s ) {
+			return s == symbol;
+		} ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-const std::vector<alphabet::RankedSymbol>& PrefixRankedTree::getContent() const {
+const std::vector < alphabet::RankedSymbol > & PrefixRankedTree::getContent ( ) const {
 	return this->m_Data;
 }
 
-void PrefixRankedTree::setContent(std::vector<alphabet::RankedSymbol> data) {
-	arityChecksum(data);
+void PrefixRankedTree::setContent ( std::vector < alphabet::RankedSymbol > data ) {
+	arityChecksum ( data );
 
-	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
-	std::set<alphabet::RankedSymbol> unknownSymbols;
-	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));
+	std::set < alphabet::RankedSymbol > minimalAlphabet ( data.begin ( ), data.end ( ) );
+	std::set < alphabet::RankedSymbol > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), alphabet.begin ( ), alphabet.end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
 
-	if(unknownSymbols.size() > 0)
-		throw exception::AlibException("Input symbols not in the alphabet.");
+	if ( unknownSymbols.size ( ) > 0 )
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 
-	this->m_Data = std::move(data);
+	this->m_Data = std::move ( data );
 }
 
-void PrefixRankedTree::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+void PrefixRankedTree::arityChecksum ( const std::vector < alphabet::RankedSymbol > & data ) {
 	int arityChecksum = 1;
-	for(const alphabet::RankedSymbol& symbol : data) {
-		arityChecksum += symbol.getRank().getData();
+
+	for ( const alphabet::RankedSymbol & symbol : data ) {
+		arityChecksum += symbol.getRank ( ).getData ( );
 		arityChecksum -= 1;
 	}
 
-	if(arityChecksum != 0) throw exception::AlibException("The string does not form a tree");
+	if ( arityChecksum != 0 ) throw exception::AlibException ( "The string does not form a tree" );
 }
 
-bool PrefixRankedTree::isEmpty() const {
-	return this->m_Data.size() == 0;
+bool PrefixRankedTree::isEmpty ( ) const {
+	return this->m_Data.size ( ) == 0;
 }
 
-int PrefixRankedTree::compare(const PrefixRankedTree& other) const {
-	auto first = std::tie(m_Data, alphabet);
-	auto second = std::tie(other.m_Data, other.alphabet);
+int PrefixRankedTree::compare ( const PrefixRankedTree & other ) const {
+	auto first	= std::tie ( m_Data, alphabet );
+	auto second = std::tie ( other.m_Data, other.alphabet );
+
+	std::compare < decltype ( first ) > comp;
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	return comp ( first, second );
 }
 
-void PrefixRankedTree::operator >>(std::ostream& out) const {
-	if( this->isEmpty() ) {
+void PrefixRankedTree::operator >>( std::ostream & out ) const {
+	if ( this->isEmpty ( ) ) {
 		out << "(Epsilon)";
 	} else {
 		out << "(PrefixRankedTree ";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
 			out << symbol;
+
 		out << ")";
 	}
 }
 
-PrefixRankedTree::operator std::string () const {
+PrefixRankedTree::operator std::string ( ) const {
 	std::stringstream ss;
-	if( this->isEmpty() ) {
+
+	if ( this->isEmpty ( ) ) {
 		ss << "E";
 	} else {
 		ss << "\"";
-		for(const alphabet::RankedSymbol& symbol : this->m_Data)
-			ss << (std::string) symbol;
+
+		for ( const alphabet::RankedSymbol & symbol : this->m_Data )
+			ss << ( std::string ) symbol;
+
 		ss << "\"";
 	}
-	return std::move(ss).str();
+
+	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));
+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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedTree> prefixRankedTreeParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::PrefixRankedTree>(tree::PrefixRankedTree::XML_TAG_NAME, tree::PrefixRankedTree::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedTree > prefixRankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedTree > ( tree::PrefixRankedTree::XML_TAG_NAME, tree::PrefixRankedTree::parse );
+xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedTree > prefixRankedTreeParserRegister2 = xmlApi < alib::Object >::ParserRegister < tree::PrefixRankedTree > ( tree::PrefixRankedTree::XML_TAG_NAME, tree::PrefixRankedTree::parse );
 
-auto PrefixRankedTreeFromRankedTree = castApi::CastRegister<tree::PrefixRankedTree, tree::RankedTree>();
-auto PrefixRankedTreeCastBinder = castApi::CastPoolStringBinder<tree::PrefixRankedTree>(tree::PrefixRankedTree::XML_TAG_NAME);
+auto PrefixRankedTreeFromRankedTree = castApi::CastRegister < tree::PrefixRankedTree, tree::RankedTree > ( );
+auto PrefixRankedTreeCastBinder = castApi::CastPoolStringBinder < tree::PrefixRankedTree > ( tree::PrefixRankedTree::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index cc9d822e3d..cbdcb93a58 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -12,7 +12,7 @@
 #include <vector>
 
 #include "../../alphabet/RankedSymbol.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedAlphabet.h"
 
 namespace tree {
@@ -23,7 +23,7 @@ class RankedTree;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedTree : public TreeBase, public RankedAlphabet {
+class PrefixRankedTree : public RankedTreeBase, public RankedAlphabet {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 public:
@@ -31,8 +31,8 @@ public:
 	explicit PrefixRankedTree ( std::vector < alphabet::RankedSymbol > data );
 	explicit PrefixRankedTree ( const RankedTree & tree );
 
-	virtual TreeBase * clone ( ) const;
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * clone ( ) const;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	virtual bool removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol );
 
@@ -41,6 +41,10 @@ public:
 	 */
 	const std::vector < alphabet::RankedSymbol > & getContent ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedAlphabet::getAlphabet ( );
+	}
+
 	void setContent ( std::vector < alphabet::RankedSymbol > data );
 
 	void arityChecksum ( const std::vector < alphabet::RankedSymbol > & data );
diff --git a/alib2data/src/tree/ranked/RankedPattern.cpp b/alib2data/src/tree/ranked/RankedPattern.cpp
index db3598ea54..2722335ead 100644
--- a/alib2data/src/tree/ranked/RankedPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedPattern.cpp
@@ -23,144 +23,149 @@
 
 namespace tree {
 
-RankedPattern::RankedPattern(const UnrankedPattern& other) : RankedPatternAlphabet(alphabet::RankedSymbol(other.getSubtreeWildcard(), 0)) {
+RankedPattern::RankedPattern ( const UnrankedPattern & other ) : RankedPatternAlphabet ( alphabet::RankedSymbol ( other.getSubtreeWildcard ( ), 0 ) ) {
 	this->pattern = NULL;
-	RankedNode* element = other.getRoot().cloneAsRanked();
-	element->computeMinimalAlphabet(alphabet);
-	setTree(std::move(*element));
+	RankedNode * element = other.getRoot ( ).cloneAsRanked ( );
+	element->computeMinimalAlphabet ( alphabet );
+	setTree ( std::move ( * element ) );
 	delete element;
 }
 
-RankedPattern::RankedPattern(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, RankedNode pattern) : RankedPatternAlphabet(std::move(subtreeWildcard)) {
-	setAlphabet(std::move(alphabet));
+RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	setAlphabet ( std::move ( alphabet ) );
 	this->pattern = NULL;
-	setTree(std::move(pattern));
+	setTree ( std::move ( pattern ) );
 }
 
-RankedPattern::RankedPattern(alphabet::RankedSymbol subtreeWildcard, RankedNode pattern) : RankedPatternAlphabet(std::move(subtreeWildcard)) {
-	pattern.computeMinimalAlphabet(alphabet);
+RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : RankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	pattern.computeMinimalAlphabet ( alphabet );
 	this->pattern = NULL;
-	setTree(std::move(pattern));
+	setTree ( std::move ( pattern ) );
 }
 
-RankedPattern::RankedPattern(const RankedPattern& other) : RankedPatternAlphabet(other), pattern(other.pattern->clone()) {
-	this->pattern->attachTree(this);
+RankedPattern::RankedPattern ( const RankedPattern & other ) : RankedPatternAlphabet ( other ), pattern ( other.pattern->clone ( ) ) {
+	this->pattern->attachTree ( this );
 }
 
-RankedPattern::RankedPattern(RankedPattern&& other) noexcept : RankedPatternAlphabet(other), pattern(other.pattern) {
-	this->pattern->attachTree(this);
+RankedPattern::RankedPattern ( RankedPattern && other ) noexcept : RankedPatternAlphabet ( other ), pattern ( other.pattern ) {
+	this->pattern->attachTree ( this );
 	other.pattern = NULL;
 }
 
-TreeBase* RankedPattern::clone() const {
-	return new RankedPattern(*this);
+RankedTreeBase * RankedPattern::clone ( ) const {
+	return new RankedPattern ( * this );
 }
 
-TreeBase* RankedPattern::plunder() && {
-	return new RankedPattern(std::move(*this));
+RankedTreeBase * RankedPattern::plunder ( ) && {
+	return new RankedPattern ( std::move ( * this ) );
 }
 
-RankedPattern& RankedPattern::operator=(const RankedPattern& other) {
-	if (this == &other) {
-		return *this;
-	}
+RankedPattern & RankedPattern::operator =( const RankedPattern & other ) {
+	if ( this == & other )
+		return * this;
 
-	*this = RankedPattern(other);
+	* this = RankedPattern ( other );
 
-	return *this;
+	return * this;
 }
 
-RankedPattern& RankedPattern::operator=(RankedPattern&& other) noexcept {
-	std::swap(this->pattern, other.pattern);
-	std::swap(this->alphabet, other.alphabet);
-	std::swap(this->subtreeWildcard, other.subtreeWildcard);
-	return *this;
+RankedPattern & RankedPattern::operator =( RankedPattern && other ) noexcept {
+	std::swap ( this->pattern, other.pattern );
+	std::swap ( this->alphabet, other.alphabet );
+	std::swap ( this->subtreeWildcard, other.subtreeWildcard );
+
+	return * this;
 }
 
-RankedPattern::~RankedPattern() noexcept {
+RankedPattern::~RankedPattern ( ) noexcept {
 	delete pattern;
 }
 
-const RankedNode& RankedPattern::getRoot() const {
-	return *pattern;
+const RankedNode & RankedPattern::getRoot ( ) const {
+	return * pattern;
 }
 
-RankedNode& RankedPattern::getRoot() {
-	return *pattern;
+RankedNode & RankedPattern::getRoot ( ) {
+	return * pattern;
 }
 
-void RankedPattern::setTree(RankedNode pattern) {
+void RankedPattern::setTree ( RankedNode pattern ) {
 	delete this->pattern;
-	this->pattern = std::move(pattern).plunder();
-	if(!this->pattern->attachTree(this)) {
+	this->pattern = std::move ( pattern ).plunder ( );
+
+	if ( !this->pattern->attachTree ( this ) ) {
 		delete this->pattern;
-		throw exception::AlibException("Input symbols not in the alphabet.");
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 	}
 }
 
-bool RankedPattern::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(this->pattern->testSymbol(symbol))
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool RankedPattern::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( this->pattern->testSymbol ( symbol ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	if(this->subtreeWildcard == symbol)
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtreeWildcard.");
+	if ( this->subtreeWildcard == symbol )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is subtreeWildcard." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-void RankedPattern::operator >>(std::ostream& out) const {
-	out << "(RankedPattern " << *(this->pattern) << ")";
+void RankedPattern::operator >>( std::ostream & out ) const {
+	out << "(RankedPattern " << * ( this->pattern ) << ")";
 }
 
-int RankedPattern::compare(const RankedPattern& other) const {
-	int res = pattern->compare(*other.pattern);
-	if(res == 0) {
-		std::compare<alphabet::RankedSymbol> comp;
-		res = comp(subtreeWildcard, other.subtreeWildcard);
+int RankedPattern::compare ( const RankedPattern & other ) const {
+	int res = pattern->compare ( * other.pattern );
+
+	if ( res == 0 ) {
+		std::compare < alphabet::RankedSymbol > comp;
+		res = comp ( subtreeWildcard, other.subtreeWildcard );
 	}
-	if(res == 0) {
-		std::compare<std::set<alphabet::RankedSymbol>> comp;
-		res = comp(alphabet, other.alphabet);
+
+	if ( res == 0 ) {
+		std::compare < std::set < alphabet::RankedSymbol > > comp;
+		res = comp ( alphabet, other.alphabet );
 	}
+
 	return res;
 }
 
-void RankedPattern::nicePrint(std::ostream & os) const {
-	pattern -> nicePrint(os);
+void RankedPattern::nicePrint ( std::ostream & os ) const {
+	pattern->nicePrint ( os );
 }
 
-RankedPattern::operator std::string () const {
+RankedPattern::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	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));
+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);
+	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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::RankedPattern> rankedPatternParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::RankedPattern>(tree::RankedPattern::XML_TAG_NAME, tree::RankedPattern::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::RankedPattern > rankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedPattern > ( tree::RankedPattern::XML_TAG_NAME, tree::RankedPattern::parse );
+xmlApi < alib::Object >::ParserRegister < tree::RankedPattern > rankedPatternParserRegister2 = xmlApi < alib::Object >::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 8ef05bd619..63cb4bce6b 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -13,7 +13,7 @@
 #include <string>
 #include <set>
 #include "RankedNode.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedPatternAlphabet.h"
 
 namespace tree {
@@ -25,7 +25,7 @@ class UnrankedPattern;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class RankedPattern : public TreeBase, public RankedPatternAlphabet {
+class RankedPattern : public RankedTreeBase, public RankedPatternAlphabet {
 protected:
 	RankedNode * pattern;
 
@@ -33,12 +33,12 @@ public:
 	/**
 	 * @copydoc RankedNode::clone() const
 	 */
-	virtual TreeBase * clone ( ) const;
+	virtual RankedTreeBase * clone ( ) const;
 
 	/**
 	 * @copydoc RankedNode::plunder() const
 	 */
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	explicit RankedPattern ( const UnrankedPattern & other );
 	explicit RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern );
@@ -59,6 +59,10 @@ public:
 	 */
 	const RankedNode & getRoot ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedPatternAlphabet::getAlphabet ( );
+	}
+
 	/**
 	 * @return Root node of the regular expression pattern
 	 */
diff --git a/alib2data/src/tree/ranked/RankedTree.cpp b/alib2data/src/tree/ranked/RankedTree.cpp
index 04382365b4..ad734dfb2b 100644
--- a/alib2data/src/tree/ranked/RankedTree.cpp
+++ b/alib2data/src/tree/ranked/RankedTree.cpp
@@ -23,136 +23,140 @@
 
 namespace tree {
 
-RankedTree::RankedTree(const UnrankedTree& other) {
+RankedTree::RankedTree ( const UnrankedTree & other ) {
 	this->tree = NULL;
-	RankedNode* element = other.getRoot().cloneAsRanked();
-	element->computeMinimalAlphabet(alphabet);
-	setTree(std::move(*element));
+	RankedNode * element = other.getRoot ( ).cloneAsRanked ( );
+	element->computeMinimalAlphabet ( alphabet );
+	setTree ( std::move ( * element ) );
 	delete element;
 }
 
-RankedTree::RankedTree(std::set<alphabet::RankedSymbol> alphabet, RankedNode tree) {
-	this->alphabet = std::move(alphabet);
+RankedTree::RankedTree ( std::set < alphabet::RankedSymbol > alphabet, RankedNode tree ) {
+	this->alphabet = std::move ( alphabet );
 	this->tree = NULL;
-	setTree(std::move(tree));
+	setTree ( std::move ( tree ) );
 }
 
-RankedTree::RankedTree(RankedNode tree) {
-	tree.computeMinimalAlphabet(alphabet);
+RankedTree::RankedTree ( RankedNode tree ) {
+	tree.computeMinimalAlphabet ( alphabet );
 	this->tree = NULL;
-	setTree(std::move(tree));
+	setTree ( std::move ( tree ) );
 }
 
-RankedTree::RankedTree(const RankedTree& other) : tree(other.tree->clone()) {
+RankedTree::RankedTree ( const RankedTree & other ) : tree ( other.tree->clone ( ) ) {
 	alphabet = other.alphabet;
-	this->tree->attachTree(this);
+	this->tree->attachTree ( this );
 }
 
-RankedTree::RankedTree(RankedTree&& other) noexcept : tree(other.tree) {
-	alphabet = std::move(other.alphabet);
-	this->tree->attachTree(this);
+RankedTree::RankedTree ( RankedTree && other ) noexcept : tree ( other.tree ) {
+	alphabet = std::move ( other.alphabet );
+	this->tree->attachTree ( this );
 	other.tree = NULL;
 }
 
-TreeBase* RankedTree::clone() const {
-	return new RankedTree(*this);
+RankedTreeBase * RankedTree::clone ( ) const {
+	return new RankedTree ( * this );
 }
 
-TreeBase* RankedTree::plunder() && {
-	return new RankedTree(std::move(*this));
+RankedTreeBase * RankedTree::plunder ( ) && {
+	return new RankedTree ( std::move ( * this ) );
 }
 
-RankedTree& RankedTree::operator=(const RankedTree& other) {
-	if (this == &other) {
-		return *this;
-	}
+RankedTree & RankedTree::operator =( const RankedTree & other ) {
+	if ( this == & other )
+		return * this;
 
-	*this = RankedTree(other);
+	* this = RankedTree ( other );
 
-	return *this;
+	return * this;
 }
 
-RankedTree& RankedTree::operator=(RankedTree&& other) noexcept {
-	std::swap(this->tree, other.tree);
-	std::swap(this->alphabet, other.alphabet);
-	return *this;
+RankedTree & RankedTree::operator =( RankedTree && other ) noexcept {
+	std::swap ( this->tree, other.tree );
+	std::swap ( this->alphabet, other.alphabet );
+
+	return * this;
 }
 
-RankedTree::~RankedTree() noexcept {
+RankedTree::~RankedTree ( ) noexcept {
 	delete tree;
 }
 
-const RankedNode& RankedTree::getRoot() const {
-	return *tree;
+const RankedNode & RankedTree::getRoot ( ) const {
+	return * tree;
 }
 
-RankedNode& RankedTree::getRoot() {
-	return *tree;
+RankedNode & RankedTree::getRoot ( ) {
+	return * tree;
 }
 
-void RankedTree::setTree(RankedNode tree) {
+void RankedTree::setTree ( RankedNode tree ) {
 	delete this->tree;
-	this->tree = std::move(tree).plunder();
-	if(!this->tree->attachTree(this)) {
+	this->tree = std::move ( tree ).plunder ( );
+
+	if ( !this->tree->attachTree ( this ) ) {
 		delete this->tree;
-		throw exception::AlibException("Input symbols not in the alphabet.");
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 	}
 }
 
-bool RankedTree::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
-	if(this->tree->testSymbol(symbol))
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool RankedTree::removeSymbolFromAlphabet ( const alphabet::RankedSymbol & symbol ) {
+	if ( this->tree->testSymbol ( symbol ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-void RankedTree::operator >>(std::ostream& out) const {
-	out << "(RankedTree " << *(this->tree) << ")";
+void RankedTree::operator >>( std::ostream & out ) const {
+	out << "(RankedTree " << * ( this->tree ) << ")";
 }
 
-int RankedTree::compare(const RankedTree& other) const {
-	int res = tree->compare(*other.tree);
-	if(res == 0) {
-		std::compare<std::set<alphabet::RankedSymbol>> comp;
-		res = comp(alphabet, other.alphabet);
+int RankedTree::compare ( const RankedTree & other ) const {
+	int res = tree->compare ( * other.tree );
+
+	if ( res == 0 ) {
+		std::compare < std::set < alphabet::RankedSymbol > > comp;
+		res = comp ( alphabet, other.alphabet );
 	}
+
 	return res;
 }
 
-void RankedTree::nicePrint(std::ostream & os) const {
-	tree -> nicePrint(os);
+void RankedTree::nicePrint ( std::ostream & os ) const {
+	tree->nicePrint ( os );
 }
 
-RankedTree::operator std::string () const {
+RankedTree::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	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));
+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);
+	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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::RankedTree> rankedTreeParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::RankedTree>(tree::RankedTree::XML_TAG_NAME, tree::RankedTree::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::RankedTree > rankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedTree > ( tree::RankedTree::XML_TAG_NAME, tree::RankedTree::parse );
+xmlApi < alib::Object >::ParserRegister < tree::RankedTree > rankedTreeParserRegister2 = xmlApi < alib::Object >::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 6bb057aaf3..3ae1884673 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -13,7 +13,7 @@
 #include <string>
 #include <set>
 #include "RankedNode.h"
-#include "../TreeBase.h"
+#include "../RankedTreeBase.h"
 #include "../common/RankedAlphabet.h"
 
 namespace tree {
@@ -25,7 +25,7 @@ class UnrankedTree;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of RegExpElement.
  */
-class RankedTree : public TreeBase, public RankedAlphabet {
+class RankedTree : public RankedTreeBase, public RankedAlphabet {
 protected:
 	RankedNode * tree;
 
@@ -33,12 +33,12 @@ public:
 	/**
 	 * @copydoc RankedNode::clone() const
 	 */
-	virtual TreeBase * clone ( ) const;
+	virtual RankedTreeBase * clone ( ) const;
 
 	/**
 	 * @copydoc RankedNode::plunder() const
 	 */
-	virtual TreeBase * plunder ( ) &&;
+	virtual RankedTreeBase * plunder ( ) &&;
 
 	explicit RankedTree ( const UnrankedTree & other );
 	explicit RankedTree ( std::set < alphabet::RankedSymbol > alphabet, RankedNode tree );
@@ -59,6 +59,10 @@ public:
 	 */
 	const RankedNode & getRoot ( ) const;
 
+	const std::set < alphabet::RankedSymbol > & getAlphabet ( ) const {
+		return RankedAlphabet::getAlphabet ( );
+	}
+
 	/**
 	 * @return Root node of the regular expression tree
 	 */
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.cpp b/alib2data/src/tree/unranked/UnrankedPattern.cpp
index 5de35f4f9c..4ca331c008 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedPattern.cpp
@@ -23,144 +23,149 @@
 
 namespace tree {
 
-UnrankedPattern::UnrankedPattern(const RankedPattern& other) : UnrankedPatternAlphabet(other.getSubtreeWildcard().getSymbol()) {
+UnrankedPattern::UnrankedPattern ( const RankedPattern & other ) : UnrankedPatternAlphabet ( other.getSubtreeWildcard ( ).getSymbol ( ) ) {
 	this->pattern = NULL;
-	UnrankedNode* element = other.getRoot().cloneAsUnranked();
-	element->computeMinimalAlphabet(alphabet);
-	setTree(std::move(*element));
+	UnrankedNode * element = other.getRoot ( ).cloneAsUnranked ( );
+	element->computeMinimalAlphabet ( alphabet );
+	setTree ( std::move ( * element ) );
 	delete element;
 }
 
-UnrankedPattern::UnrankedPattern(alphabet::Symbol subtreeWildcard, std::set<alphabet::Symbol> alphabet, UnrankedNode pattern) : UnrankedPatternAlphabet(std::move(subtreeWildcard)) {
-	setAlphabet(std::move(alphabet));
+UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : UnrankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	setAlphabet ( std::move ( alphabet ) );
 	this->pattern = NULL;
-	setTree(std::move(pattern));
+	setTree ( std::move ( pattern ) );
 }
 
-UnrankedPattern::UnrankedPattern(alphabet::Symbol subtreeWildcard, UnrankedNode pattern) : UnrankedPatternAlphabet(std::move(subtreeWildcard)) {
-	pattern.computeMinimalAlphabet(alphabet);
+UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, UnrankedNode pattern ) : UnrankedPatternAlphabet ( std::move ( subtreeWildcard ) ) {
+	pattern.computeMinimalAlphabet ( alphabet );
 	this->pattern = NULL;
-	setTree(std::move(pattern));
+	setTree ( std::move ( pattern ) );
 }
 
-UnrankedPattern::UnrankedPattern(const UnrankedPattern& other) : UnrankedPatternAlphabet(other), pattern(other.pattern->clone()) {
-	this->pattern->attachTree(this);
+UnrankedPattern::UnrankedPattern ( const UnrankedPattern & other ) : UnrankedPatternAlphabet ( other ), pattern ( other.pattern->clone ( ) ) {
+	this->pattern->attachTree ( this );
 }
 
-UnrankedPattern::UnrankedPattern(UnrankedPattern&& other) noexcept : UnrankedPatternAlphabet(other), pattern(other.pattern) {
-	this->pattern->attachTree(this);
+UnrankedPattern::UnrankedPattern ( UnrankedPattern && other ) noexcept : UnrankedPatternAlphabet ( other ), pattern ( other.pattern ) {
+	this->pattern->attachTree ( this );
 	other.pattern = NULL;
 }
 
-TreeBase* UnrankedPattern::clone() const {
-	return new UnrankedPattern(*this);
+UnrankedTreeBase * UnrankedPattern::clone ( ) const {
+	return new UnrankedPattern ( * this );
 }
 
-TreeBase* UnrankedPattern::plunder() && {
-	return new UnrankedPattern(std::move(*this));
+UnrankedTreeBase * UnrankedPattern::plunder ( ) && {
+	return new UnrankedPattern ( std::move ( * this ) );
 }
 
-UnrankedPattern& UnrankedPattern::operator=(const UnrankedPattern& other) {
-	if (this == &other) {
-		return *this;
-	}
+UnrankedPattern & UnrankedPattern::operator =( const UnrankedPattern & other ) {
+	if ( this == & other )
+		return * this;
 
-	*this = UnrankedPattern(other);
+	* this = UnrankedPattern ( other );
 
-	return *this;
+	return * this;
 }
 
-UnrankedPattern& UnrankedPattern::operator=(UnrankedPattern&& other) noexcept {
-	std::swap(this->pattern, other.pattern);
-	std::swap(this->alphabet, other.alphabet);
-	std::swap(this->subtreeWildcard, other.subtreeWildcard);
-	return *this;
+UnrankedPattern & UnrankedPattern::operator =( UnrankedPattern && other ) noexcept {
+	std::swap ( this->pattern, other.pattern );
+	std::swap ( this->alphabet, other.alphabet );
+	std::swap ( this->subtreeWildcard, other.subtreeWildcard );
+
+	return * this;
 }
 
-UnrankedPattern::~UnrankedPattern() noexcept {
+UnrankedPattern::~UnrankedPattern ( ) noexcept {
 	delete pattern;
 }
 
-const UnrankedNode& UnrankedPattern::getRoot() const {
-	return *pattern;
+const UnrankedNode & UnrankedPattern::getRoot ( ) const {
+	return * pattern;
 }
 
-UnrankedNode& UnrankedPattern::getRoot() {
-	return *pattern;
+UnrankedNode & UnrankedPattern::getRoot ( ) {
+	return * pattern;
 }
 
-void UnrankedPattern::setTree(UnrankedNode pattern) {
+void UnrankedPattern::setTree ( UnrankedNode pattern ) {
 	delete this->pattern;
-	this->pattern = std::move(pattern).plunder();
-	if(!this->pattern->attachTree(this)) {
+	this->pattern = std::move ( pattern ).plunder ( );
+
+	if ( !this->pattern->attachTree ( this ) ) {
 		delete this->pattern;
-		throw exception::AlibException("Input symbols not in the alphabet.");
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 	}
 }
 
-bool UnrankedPattern::removeSymbolFromAlphabet(const alphabet::Symbol & symbol) {
-	if(this->pattern->testSymbol(symbol))
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool UnrankedPattern::removeSymbolFromAlphabet ( const alphabet::Symbol & symbol ) {
+	if ( this->pattern->testSymbol ( symbol ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	if(this->subtreeWildcard == symbol)
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtree wildcard.");
+	if ( this->subtreeWildcard == symbol )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is subtree wildcard." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-void UnrankedPattern::operator >>(std::ostream& out) const {
-	out << "(UnrankedPattern " << *(this->pattern) << ")";
+void UnrankedPattern::operator >>( std::ostream & out ) const {
+	out << "(UnrankedPattern " << * ( this->pattern ) << ")";
 }
 
-int UnrankedPattern::compare(const UnrankedPattern& other) const {
-	int res = pattern->compare(*other.pattern);
-	if(res == 0) {
-		std::compare<alphabet::Symbol> comp;
-		res = comp(subtreeWildcard, other.subtreeWildcard);
+int UnrankedPattern::compare ( const UnrankedPattern & other ) const {
+	int res = pattern->compare ( * other.pattern );
+
+	if ( res == 0 ) {
+		std::compare < alphabet::Symbol > comp;
+		res = comp ( subtreeWildcard, other.subtreeWildcard );
 	}
-	if(res == 0) {
-		std::compare<std::set<alphabet::Symbol>> comp;
-		res = comp(alphabet, other.alphabet);
+
+	if ( res == 0 ) {
+		std::compare < std::set < alphabet::Symbol > > comp;
+		res = comp ( alphabet, other.alphabet );
 	}
+
 	return res;
 }
 
-void UnrankedPattern::nicePrint(std::ostream & os) const {
-	pattern -> nicePrint(os);
+void UnrankedPattern::nicePrint ( std::ostream & os ) const {
+	pattern->nicePrint ( os );
 }
 
-UnrankedPattern::operator std::string () const {
+UnrankedPattern::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	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));
+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);
+	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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::UnrankedPattern> unrankedPatternParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::UnrankedPattern>(tree::UnrankedPattern::XML_TAG_NAME, tree::UnrankedPattern::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::UnrankedPattern > unrankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::UnrankedPattern > ( tree::UnrankedPattern::XML_TAG_NAME, tree::UnrankedPattern::parse );
+xmlApi < alib::Object >::ParserRegister < tree::UnrankedPattern > unrankedPatternParserRegister2 = xmlApi < alib::Object >::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 d10b86ee1e..2e003e1b0f 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -13,7 +13,7 @@
 #include <string>
 #include <set>
 #include "UnrankedNode.h"
-#include "../TreeBase.h"
+#include "../UnrankedTreeBase.h"
 #include "../common/UnrankedPatternAlphabet.h"
 
 namespace tree {
@@ -25,7 +25,7 @@ class RankedPattern;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class UnrankedPattern : public TreeBase, public UnrankedPatternAlphabet {
+class UnrankedPattern : public UnrankedTreeBase, public UnrankedPatternAlphabet {
 protected:
 	UnrankedNode * pattern;
 
@@ -33,12 +33,12 @@ public:
 	/**
 	 * @copydoc UnrankedNode::clone() const
 	 */
-	virtual TreeBase * clone ( ) const;
+	virtual UnrankedTreeBase * clone ( ) const;
 
 	/**
 	 * @copydoc UnrankedNode::plunder() const
 	 */
-	virtual TreeBase * plunder ( ) &&;
+	virtual UnrankedTreeBase * plunder ( ) &&;
 
 	explicit UnrankedPattern ( const RankedPattern & other );
 	explicit UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern );
@@ -59,6 +59,10 @@ public:
 	 */
 	const UnrankedNode & getRoot ( ) const;
 
+	const std::set < alphabet::Symbol > & getAlphabet ( ) const {
+		return UnrankedPatternAlphabet::getAlphabet ( );
+	}
+
 	/**
 	 * @return Root node of the regular expression pattern
 	 */
diff --git a/alib2data/src/tree/unranked/UnrankedTree.cpp b/alib2data/src/tree/unranked/UnrankedTree.cpp
index 30371fd14f..7b49c3cf8e 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.cpp
+++ b/alib2data/src/tree/unranked/UnrankedTree.cpp
@@ -23,136 +23,140 @@
 
 namespace tree {
 
-UnrankedTree::UnrankedTree(const RankedTree& other) {
+UnrankedTree::UnrankedTree ( const RankedTree & other ) {
 	this->tree = NULL;
-	UnrankedNode* element = other.getRoot().cloneAsUnranked();
-	element->computeMinimalAlphabet(alphabet);
-	setTree(std::move(*element));
+	UnrankedNode * element = other.getRoot ( ).cloneAsUnranked ( );
+	element->computeMinimalAlphabet ( alphabet );
+	setTree ( std::move ( * element ) );
 	delete element;
 }
 
-UnrankedTree::UnrankedTree(std::set<alphabet::Symbol> alphabet, UnrankedNode tree) {
-	setAlphabet(std::move(alphabet));
+UnrankedTree::UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree ) {
+	setAlphabet ( std::move ( alphabet ) );
 	this->tree = NULL;
-	setTree(std::move(tree));
+	setTree ( std::move ( tree ) );
 }
 
-UnrankedTree::UnrankedTree(UnrankedNode tree) {
-	tree.computeMinimalAlphabet(alphabet);
+UnrankedTree::UnrankedTree ( UnrankedNode tree ) {
+	tree.computeMinimalAlphabet ( alphabet );
 	this->tree = NULL;
-	setTree(std::move(tree));
+	setTree ( std::move ( tree ) );
 }
 
-UnrankedTree::UnrankedTree(const UnrankedTree& other) : tree(other.tree->clone()) {
+UnrankedTree::UnrankedTree ( const UnrankedTree & other ) : tree ( other.tree->clone ( ) ) {
 	alphabet = other.alphabet;
-	this->tree->attachTree(this);
+	this->tree->attachTree ( this );
 }
 
-UnrankedTree::UnrankedTree(UnrankedTree&& other) noexcept : tree(other.tree) {
-	alphabet = std::move(other.alphabet);
-	this->tree->attachTree(this);
+UnrankedTree::UnrankedTree ( UnrankedTree && other ) noexcept : tree ( other.tree ) {
+	alphabet = std::move ( other.alphabet );
+	this->tree->attachTree ( this );
 	other.tree = NULL;
 }
 
-TreeBase* UnrankedTree::clone() const {
-	return new UnrankedTree(*this);
+UnrankedTreeBase * UnrankedTree::clone ( ) const {
+	return new UnrankedTree ( * this );
 }
 
-TreeBase* UnrankedTree::plunder() && {
-	return new UnrankedTree(std::move(*this));
+UnrankedTreeBase * UnrankedTree::plunder ( ) && {
+	return new UnrankedTree ( std::move ( * this ) );
 }
 
-UnrankedTree& UnrankedTree::operator=(const UnrankedTree& other) {
-	if (this == &other) {
-		return *this;
-	}
+UnrankedTree & UnrankedTree::operator =( const UnrankedTree & other ) {
+	if ( this == & other )
+		return * this;
 
-	*this = UnrankedTree(other);
+	* this = UnrankedTree ( other );
 
-	return *this;
+	return * this;
 }
 
-UnrankedTree& UnrankedTree::operator=(UnrankedTree&& other) noexcept {
-	std::swap(this->tree, other.tree);
-	std::swap(this->alphabet, other.alphabet);
-	return *this;
+UnrankedTree & UnrankedTree::operator =( UnrankedTree && other ) noexcept {
+	std::swap ( this->tree, other.tree );
+	std::swap ( this->alphabet, other.alphabet );
+
+	return * this;
 }
 
-UnrankedTree::~UnrankedTree() noexcept {
+UnrankedTree::~UnrankedTree ( ) noexcept {
 	delete tree;
 }
 
-const UnrankedNode& UnrankedTree::getRoot() const {
-	return *tree;
+const UnrankedNode & UnrankedTree::getRoot ( ) const {
+	return * tree;
 }
 
-UnrankedNode& UnrankedTree::getRoot() {
-	return *tree;
+UnrankedNode & UnrankedTree::getRoot ( ) {
+	return * tree;
 }
 
-void UnrankedTree::setTree(UnrankedNode tree) {
+void UnrankedTree::setTree ( UnrankedNode tree ) {
 	delete this->tree;
-	this->tree = std::move(tree).plunder();
-	if(!this->tree->attachTree(this)) {
+	this->tree = std::move ( tree ).plunder ( );
+
+	if ( !this->tree->attachTree ( this ) ) {
 		delete this->tree;
-		throw exception::AlibException("Input symbols not in the alphabet.");
+		throw exception::AlibException ( "Input symbols not in the alphabet." );
 	}
 }
 
-bool UnrankedTree::removeSymbolFromAlphabet(const alphabet::Symbol & symbol) {
-	if(this->tree->testSymbol(symbol))
-		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+bool UnrankedTree::removeSymbolFromAlphabet ( const alphabet::Symbol & symbol ) {
+	if ( this->tree->testSymbol ( symbol ) )
+		throw exception::AlibException ( "Input symbol \"" + ( std::string ) symbol + "\" is used." );
 
-	return alphabet.erase(symbol);
+	return alphabet.erase ( symbol );
 }
 
-void UnrankedTree::operator >>(std::ostream& out) const {
-	out << "(UnrankedTree " << *(this->tree) << ")";
+void UnrankedTree::operator >>( std::ostream & out ) const {
+	out << "(UnrankedTree " << * ( this->tree ) << ")";
 }
 
-int UnrankedTree::compare(const UnrankedTree& other) const {
-	int res = tree->compare(*other.tree);
-	if(res == 0) {
-		std::compare<std::set<alphabet::Symbol>> comp;
-		res = comp(alphabet, other.alphabet);
+int UnrankedTree::compare ( const UnrankedTree & other ) const {
+	int res = tree->compare ( * other.tree );
+
+	if ( res == 0 ) {
+		std::compare < std::set < alphabet::Symbol > > comp;
+		res = comp ( alphabet, other.alphabet );
 	}
+
 	return res;
 }
 
-void UnrankedTree::nicePrint(std::ostream & os) const {
-	tree -> nicePrint(os);
+void UnrankedTree::nicePrint ( std::ostream & os ) const {
+	tree->nicePrint ( os );
 }
 
-UnrankedTree::operator std::string () const {
+UnrankedTree::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	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));
+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);
+	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);
+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);
-xmlApi<alib::Object>::ParserRegister<tree::UnrankedTree> unrankedTreeParserRegister2 = xmlApi<alib::Object>::ParserRegister<tree::UnrankedTree>(tree::UnrankedTree::XML_TAG_NAME, tree::UnrankedTree::parse);
+xmlApi < tree::Tree >::ParserRegister < tree::UnrankedTree > unrankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::UnrankedTree > ( tree::UnrankedTree::XML_TAG_NAME, tree::UnrankedTree::parse );
+xmlApi < alib::Object >::ParserRegister < tree::UnrankedTree > unrankedTreeParserRegister2 = xmlApi < alib::Object >::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 aa4fbe9a0b..811a0c1610 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -13,7 +13,7 @@
 #include <string>
 #include <set>
 #include "UnrankedNode.h"
-#include "../TreeBase.h"
+#include "../UnrankedTreeBase.h"
 #include "../common/UnrankedAlphabet.h"
 
 namespace tree {
@@ -25,7 +25,7 @@ class RankedTree;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of RegExpElement.
  */
-class UnrankedTree : public TreeBase, public UnrankedAlphabet {
+class UnrankedTree : public UnrankedTreeBase, public UnrankedAlphabet {
 protected:
 	UnrankedNode * tree;
 
@@ -33,12 +33,12 @@ public:
 	/**
 	 * @copydoc UnrankedNode::clone() const
 	 */
-	virtual TreeBase * clone ( ) const;
+	virtual UnrankedTreeBase * clone ( ) const;
 
 	/**
 	 * @copydoc UnrankedNode::plunder() const
 	 */
-	virtual TreeBase * plunder ( ) &&;
+	virtual UnrankedTreeBase * plunder ( ) &&;
 
 	explicit UnrankedTree ( const RankedTree & other );
 	explicit UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree );
@@ -59,6 +59,10 @@ public:
 	 */
 	const UnrankedNode & getRoot ( ) const;
 
+	const std::set < alphabet::Symbol > & getAlphabet ( ) const {
+		return UnrankedAlphabet::getAlphabet ( );
+	}
+
 	/**
 	 * @return Root node of the regular expression tree
 	 */
-- 
GitLab