From 7dd01715ceb6841f3547dde52698d1278418ab52 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Tue, 11 Apr 2017 15:23:33 +0200
Subject: [PATCH] normalize trees

---
 .../src/alphabet/common/SymbolNormalize.h     | 12 ++++
 alib2data/src/tree/common/TreeNormalize.h     | 56 +++++++++++++++++++
 .../ranked/PrefixRankedBarNonlinearPattern.h  | 24 ++++++--
 .../src/tree/ranked/PrefixRankedBarPattern.h  | 17 +++++-
 .../src/tree/ranked/PrefixRankedBarTree.h     | 11 +++-
 .../ranked/PrefixRankedNonlinearPattern.h     | 16 +++++-
 .../src/tree/ranked/PrefixRankedPattern.h     | 11 +++-
 alib2data/src/tree/ranked/PrefixRankedTree.h  |  8 +++
 .../src/tree/ranked/RankedNonlinearPattern.h  | 34 +++++++----
 alib2data/src/tree/ranked/RankedPattern.h     | 33 +++++++----
 alib2data/src/tree/ranked/RankedTree.h        | 33 +++++++----
 alib2data/src/tree/unranked/PrefixBarTree.h   | 11 +++-
 .../tree/unranked/UnrankedNonlinearPattern.h  | 32 +++++++----
 alib2data/src/tree/unranked/UnrankedPattern.h | 31 ++++++----
 alib2data/src/tree/unranked/UnrankedTree.h    | 32 +++++++----
 15 files changed, 276 insertions(+), 85 deletions(-)
 create mode 100644 alib2data/src/tree/common/TreeNormalize.h

diff --git a/alib2data/src/alphabet/common/SymbolNormalize.h b/alib2data/src/alphabet/common/SymbolNormalize.h
index 670b37de4b..996090ca3b 100644
--- a/alib2data/src/alphabet/common/SymbolNormalize.h
+++ b/alib2data/src/alphabet/common/SymbolNormalize.h
@@ -36,6 +36,9 @@ public:
 
 	template < class SymbolType >
 	static std::vector < DefaultSymbolType > normalizeSymbols ( std::vector < SymbolType > && symbols );
+
+	template < class SymbolType, class RankType >
+	static std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedSymbols ( std::vector < std::ranked_symbol < SymbolType, RankType > > && symbols );
 };
 
 template < class SymbolType >
@@ -75,6 +78,15 @@ std::vector < DefaultSymbolType > SymbolNormalize::normalizeSymbols ( std::vecto
 	return res;
 }
 
+template < class SymbolType, class RankType >
+std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > SymbolNormalize::normalizeRankedSymbols ( std::vector < std::ranked_symbol < SymbolType, RankType > > && symbols ) {
+	std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > res;
+	for ( std::ranked_symbol < SymbolType, RankType > & symbol : symbols ) {
+		res.push_back ( normalizeRankedSymbol ( std::move ( symbol ) ) );
+	}
+	return res;
+}
+
 } /* namespace alphabet */
 
 #endif /* SYMBOL_NORMALIZE_H_ */
diff --git a/alib2data/src/tree/common/TreeNormalize.h b/alib2data/src/tree/common/TreeNormalize.h
new file mode 100644
index 0000000000..bc71ff03e4
--- /dev/null
+++ b/alib2data/src/tree/common/TreeNormalize.h
@@ -0,0 +1,56 @@
+/*
+ * TreeNormalize.h
+ *
+ *  Created on: Mar 31, 2017
+ *      Author: Jan Travnicek
+ */
+
+#ifndef TREE_NORMALIZE_H_
+#define TREE_NORMALIZE_H_
+
+#include <tree>
+
+#include <alphabet/RankedSymbol.h>
+#include <alphabet/common/SymbolNormalize.h>
+
+namespace tree {
+
+/**
+ * This class contains methods to print XML representation of automata to the output stream.
+ */
+class TreeNormalize {
+public:
+	template < class SymbolType >
+	static std::tree < DefaultSymbolType > normalizeTree ( std::tree < SymbolType > && tree );
+
+	template < class SymbolType, class RankType >
+	static std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > normalizeRankedTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > && tree );
+
+};
+
+template < class SymbolType >
+std::tree < DefaultSymbolType > TreeNormalize::normalizeTree ( std::tree < SymbolType > && tree ) {
+	std::vector < std::tree < DefaultSymbolType > > children;
+
+	for ( std::tree < SymbolType > & child : tree.getChildren ( ) ) {
+		children.push_back ( normalizeTree ( std::move ( child ) ) );
+	}
+
+	return std::tree < DefaultSymbolType > ( alphabet::SymbolNormalize::normalizeSymbol ( std::move ( tree.getData ( ) ) ), std::move ( children ) );
+}
+
+template < class SymbolType, class RankType >
+std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > TreeNormalize::normalizeRankedTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > && tree ) {
+	std::vector < std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > > children;
+
+	for ( std::tree < std::ranked_symbol < SymbolType, RankType > > & child : tree.getChildren ( ) ) {
+		children.push_back ( normalizeRankedTree ( std::move ( child ) ) );
+	}
+
+	return std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > ( alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( tree.getData ( ) ) ), std::move ( children ) );
+}
+
+} /* namespace tree */
+
+#endif /* TREE_NORMALIZE_H_ */
+
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
index ae2b41614b..63d7ad9908 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -26,10 +26,11 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
-#include "../../alphabet/VariablesBarSymbol.h"
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/BarSymbol.h>
+#include <alphabet/VariablesBarSymbol.h>
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -50,9 +51,9 @@ class PrefixRankedBarNonlinearPattern : public RankedTreeBase, public std::Compo
 	static std::vector < std::ranked_symbol < SymbolType, RankType > > toPrefixRankedBar ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & node, const std::ranked_symbol < SymbolType, RankType > & subtreeWildcard, const std::set < std::ranked_symbol < SymbolType, RankType > > & nonlinearVariables, const SymbolType & barBase, const std::ranked_symbol < SymbolType, RankType > & variablesBar );
 
 public:
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
-	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bar, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
+	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < SymbolType, RankType > > bars, std::ranked_symbol < SymbolType, RankType > variablesBar, std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::vector < std::ranked_symbol < SymbolType, RankType > > data );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedTree < SymbolType, RankType > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedPattern < SymbolType, RankType > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( SymbolType barBase, std::ranked_symbol < SymbolType, RankType > variablesBar, const RankedNonlinearPattern < SymbolType, RankType > & tree );
@@ -126,6 +127,17 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < VariablesBarSymbol > ( ).get ( ) ) );
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarNonlinearPattern < > ( std::move ( bars ), std::move ( variablesBars ), std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index 08b6516546..1688ef99ae 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -26,10 +26,11 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
-#include "../../alphabet/VariablesBarSymbol.h"
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/BarSymbol.h>
+#include <alphabet/VariablesBarSymbol.h>
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -115,6 +116,16 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > variablesBars = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < VariablesBarSymbol > ( ).get ( ) ) );
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarPattern < > ( std::move ( bars ), std::move ( variablesBars ), std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index b223692296..c0605eea9a 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -26,8 +26,9 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
+#include <alphabet/BarSymbol.h>
 
 namespace tree {
 
@@ -102,6 +103,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > bars = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < BarSymbols > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedBarTree < > ( std::move ( bars ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index 497bbf7682..2b40344f37 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -25,8 +25,9 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -110,6 +111,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -278,9 +288,9 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::vector < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
+		const std::vector < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
 
-		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		return std::find ( m_content.begin ( ), m_content.end ( ), symbol ) != m_content.end ( ) || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::PrefixRankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index c9c0adc895..edc1ae25ac 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -25,8 +25,9 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/SubtreeWildcardSymbol.h"
+#include <alphabet/SubtreeWildcardSymbol.h>
 
 namespace tree {
 
@@ -101,6 +102,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index 12e02ca1ed..0ded0a3c8d 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -25,6 +25,7 @@
 #include "../RankedTreeBase.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -93,6 +94,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = alphabet::SymbolNormalize::normalizeRankedSymbols ( std::move ( m_Data ) );
+
+		return new PrefixRankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index ed71ded39d..6b10f84e82 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -26,6 +26,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -39,7 +40,7 @@ class NonlinearAlphabet;
  */
 template < class SymbolType, class RankType >
 class RankedNonlinearPattern : public RankedTreeBase, public std::Components < RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -118,6 +119,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -127,9 +137,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -156,7 +166,7 @@ RankedTreeBase * RankedNonlinearPattern < SymbolType, RankType >::plunder ( ) &&
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedNonlinearPattern < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -183,18 +193,18 @@ void RankedNonlinearPattern < SymbolType, RankType >::setTree ( std::tree < std:
 	checkAlphabet ( pattern );
 	checkArities ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType, class RankType >
 void RankedNonlinearPattern < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedNonlinearPattern " << this->content << ")";
+	out << "(RankedNonlinearPattern " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedNonlinearPattern < SymbolType, RankType >::compare ( const RankedNonlinearPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -203,7 +213,7 @@ int RankedNonlinearPattern < SymbolType, RankType >::compare ( const RankedNonli
 
 template < class SymbolType, class RankType >
 void RankedNonlinearPattern < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -249,8 +259,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
 	}
 
 	static bool available ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index 6460d17fcc..7e236d12f2 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -26,6 +26,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -38,7 +39,7 @@ class SubtreeWildcard;
  */
 template < class SymbolType, class RankType >
 class RankedPattern : public RankedTreeBase, public std::Components < RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -112,6 +113,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::ranked_symbol < DefaultSymbolType, DefaultRankType > wildcard = alphabet::SymbolNormalize::normalizeRankedSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -121,9 +130,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedPattern < SymbolType, RankType >::RankedPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : std::Components < RankedPattern, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -146,7 +155,7 @@ RankedTreeBase * RankedPattern < SymbolType, RankType >::plunder ( ) && {
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedPattern < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -173,18 +182,18 @@ void RankedPattern < SymbolType, RankType >::setTree ( std::tree < std::ranked_s
 	checkAlphabet ( pattern );
 	checkArities ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType, class RankType >
 void RankedPattern < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedPattern " << this->content << ")";
+	out << "(RankedPattern " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedPattern < SymbolType, RankType >::compare ( const RankedPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -193,7 +202,7 @@ int RankedPattern < SymbolType, RankType >::compare ( const RankedPattern & othe
 
 template < class SymbolType, class RankType >
 void RankedPattern < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -237,8 +246,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::RankedPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index 5fc5a8c3a4..233cfa1460 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -27,6 +27,8 @@
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
 
+#include <tree/common/TreeNormalize.h>
+
 namespace tree {
 
 class GeneralAlphabet;
@@ -37,7 +39,7 @@ class GeneralAlphabet;
  */
 template < class SymbolType, class RankType >
 class RankedTree : public RankedTreeBase, public std::Components < RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > {
-	std::tree < std::ranked_symbol < SymbolType, RankType > > content;
+	std::tree < std::ranked_symbol < SymbolType, RankType > > m_content;
 
 	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
@@ -107,6 +109,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > alphabet = alphabet::SymbolNormalize::normalizeRankedAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < std::ranked_symbol < DefaultSymbolType, DefaultRankType > > content = TreeNormalize::normalizeRankedTree ( std::move ( m_content ) );
+
+		return new RankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -116,9 +125,9 @@ public:
 namespace tree {
 
 template < class SymbolType, class RankType >
-RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : std::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), content ( std::move ( tree ) ) {
-	checkAlphabet ( content );
-	checkArities ( content );
+RankedTree < SymbolType, RankType >::RankedTree ( std::set < std::ranked_symbol < SymbolType, RankType > > alphabet, std::tree < std::ranked_symbol < SymbolType, RankType > > tree ) : std::Components < RankedTree, std::ranked_symbol < SymbolType, RankType >, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+	checkAlphabet ( m_content );
+	checkArities ( m_content );
 }
 
 template < class SymbolType, class RankType >
@@ -141,7 +150,7 @@ RankedTreeBase * RankedTree < SymbolType, RankType >::plunder ( ) && {
 
 template < class SymbolType, class RankType >
 const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedTree < SymbolType, RankType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType, class RankType >
@@ -168,18 +177,18 @@ void RankedTree < SymbolType, RankType >::setTree ( std::tree < std::ranked_symb
 	checkAlphabet ( tree );
 	checkArities ( tree );
 
-	this->content = std::move ( tree );
+	this->m_content = std::move ( tree );
 }
 
 template < class SymbolType, class RankType >
 void RankedTree < SymbolType, RankType >::operator >>( std::ostream & out ) const {
-	out << "(RankedTree " << this->content << ")";
+	out << "(RankedTree " << this->m_content << ")";
 }
 
 template < class SymbolType, class RankType >
 int RankedTree < SymbolType, RankType >::compare ( const RankedTree & other ) const {
-	auto first = std::tie ( content, getAlphabet() );
-	auto second = std::tie ( other.content, other.getAlphabet() );
+	auto first = std::tie ( m_content, getAlphabet() );
+	auto second = std::tie ( other.m_content, other.getAlphabet() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -188,7 +197,7 @@ int RankedTree < SymbolType, RankType >::compare ( const RankedTree & other ) co
 
 template < class SymbolType, class RankType >
 void RankedTree < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType, class RankType >
@@ -230,8 +239,8 @@ template < class SymbolType, class RankType >
 class ComponentConstraint< ::tree::RankedTree < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::RankedTree < SymbolType, RankType > & tree, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
-		const std::tree < std::ranked_symbol < SymbolType, RankType > > & content = tree.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end();
+		const std::tree < std::ranked_symbol < SymbolType, RankType > > & m_content = tree.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end();
 	}
 
 	static bool available ( const ::tree::RankedTree < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.h b/alib2data/src/tree/unranked/PrefixBarTree.h
index 5585a4acd5..1458e0829d 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.h
+++ b/alib2data/src/tree/unranked/PrefixBarTree.h
@@ -24,8 +24,9 @@
 #include "../TreeException.h"
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
+#include <tree/common/TreeNormalize.h>
 
-#include "../../alphabet/BarSymbol.h"
+#include <alphabet/BarSymbol.h>
 
 namespace tree {
 
@@ -99,6 +100,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType bar = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < BarSymbol > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::vector < DefaultSymbolType > content = alphabet::SymbolNormalize::normalizeSymbols ( std::move ( m_Data ) );
+
+		return new PrefixBarTree < > ( std::move ( bar ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index 21116d3474..13acf19ae4 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -38,7 +39,7 @@ class NonlinearAlphabet;
  */
 template < class SymbolType >
 class UnrankedNonlinearPattern : public UnrankedTreeBase, public std::Components < UnrankedNonlinearPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -122,6 +123,15 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > nonlinearAlphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < NonlinearAlphabet > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedNonlinearPattern < > ( std::move ( wildcard ), std::move ( nonlinearAlphabet ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -131,8 +141,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
+UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedNonlinearPattern, SymbolType, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -160,7 +170,7 @@ UnrankedTreeBase * UnrankedNonlinearPattern < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedNonlinearPattern < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -177,18 +187,18 @@ template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::setTree ( std::tree < SymbolType > pattern ) {
 	checkAlphabet ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedNonlinearPattern " << this->content << ")";
+	out << "(UnrankedNonlinearPattern " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedNonlinearPattern < SymbolType >::compare ( const UnrankedNonlinearPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -197,7 +207,7 @@ int UnrankedNonlinearPattern < SymbolType >::compare ( const UnrankedNonlinearPa
 
 template < class SymbolType >
 void UnrankedNonlinearPattern < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -243,8 +253,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedNonlinearPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedNonlinearPattern < SymbolType > & pattern, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+		const std::tree<SymbolType>& m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
 	}
 
 	static bool available ( const ::tree::UnrankedNonlinearPattern < SymbolType > &, const SymbolType & ) {
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index 9fd51cf7bc..f8fd599b68 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -37,7 +38,7 @@ class SubtreeWildcard;
  */
 template < class SymbolType >
 class UnrankedPattern : public UnrankedTreeBase, public std::Components < UnrankedPattern < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -110,6 +111,14 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		DefaultSymbolType wildcard = alphabet::SymbolNormalize::normalizeSymbol ( std::move ( this->template accessElement < SubtreeWildcard > ( ).get ( ) ) );
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedPattern < > ( std::move ( wildcard ), std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -119,8 +128,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), content ( std::move ( pattern ) ) {
-	checkAlphabet ( content );
+UnrankedPattern < SymbolType >::UnrankedPattern ( SymbolType subtreeWildcard, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern ) : std::Components < UnrankedPattern, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), m_content ( std::move ( pattern ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -144,7 +153,7 @@ UnrankedTreeBase * UnrankedPattern < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedPattern < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -161,18 +170,18 @@ template < class SymbolType >
 void UnrankedPattern < SymbolType >::setTree ( std::tree < SymbolType > pattern ) {
 	checkAlphabet ( pattern );
 
-	this->content = std::move ( pattern );
+	this->m_content = std::move ( pattern );
 }
 
 template < class SymbolType >
 void UnrankedPattern < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedPattern " << this->content << ")";
+	out << "(UnrankedPattern " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedPattern < SymbolType >::compare ( const UnrankedPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard() );
+	auto first = std::tie ( m_content, getAlphabet(), getSubtreeWildcard() );
+	auto second = std::tie ( other.m_content, other.getAlphabet(), other.getSubtreeWildcard() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -181,7 +190,7 @@ int UnrankedPattern < SymbolType >::compare ( const UnrankedPattern & other ) co
 
 template < class SymbolType >
 void UnrankedPattern < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -225,8 +234,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedPattern < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedPattern < SymbolType > & pattern, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
+		const std::tree<SymbolType>& m_content = pattern.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end() || pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
 
 	static bool available ( const ::tree::UnrankedPattern < SymbolType > &, const SymbolType & ) {
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index c504e6155b..569d7a35fd 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -25,6 +25,7 @@
 #include "../common/TreeFromXMLParser.h"
 #include "../common/TreeToXMLComposer.h"
 #include "../common/TreeAuxiliary.h"
+#include <tree/common/TreeNormalize.h>
 
 namespace tree {
 
@@ -36,7 +37,7 @@ class GeneralAlphabet;
  */
 template < class SymbolType >
 class UnrankedTree : public UnrankedTreeBase, public std::Components < UnrankedTree < SymbolType >, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > {
-	std::tree < SymbolType > content;
+	std::tree < SymbolType > m_content;
 
 	void checkAlphabet ( const std::tree < SymbolType > & pattern ) const;
 
@@ -65,7 +66,7 @@ public:
 	}
 
 	/**
-	 * @return content of the tree
+	 * @return m_content of the tree
 	 */
 	const std::tree < SymbolType > & getContent ( ) const;
 
@@ -105,6 +106,13 @@ public:
 	void compose ( std::deque < sax::Token > & out ) const;
 
 	virtual alib::ObjectBase * inc ( ) &&;
+
+	virtual TreeBase * normalize ( ) && {
+		std::set < DefaultSymbolType > alphabet = alphabet::SymbolNormalize::normalizeAlphabet ( std::move ( this->template accessComponent < GeneralAlphabet > ( ).get ( ) ) );
+		std::tree < DefaultSymbolType > content = TreeNormalize::normalizeTree ( std::move ( m_content ) );
+
+		return new UnrankedTree < > ( std::move ( alphabet ), std::move ( content ) );
+	}
 };
 
 } /* namespace tree */
@@ -114,8 +122,8 @@ public:
 namespace tree {
 
 template < class SymbolType >
-UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : std::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), content ( std::move ( tree ) ) {
-	checkAlphabet ( content );
+UnrankedTree < SymbolType >::UnrankedTree ( std::set < SymbolType > alphabet, std::tree < SymbolType > tree ) : std::Components < UnrankedTree, SymbolType, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), m_content ( std::move ( tree ) ) {
+	checkAlphabet ( m_content );
 }
 
 template < class SymbolType >
@@ -139,7 +147,7 @@ UnrankedTreeBase * UnrankedTree < SymbolType >::plunder ( ) && {
 
 template < class SymbolType >
 const std::tree < SymbolType > & UnrankedTree < SymbolType >::getContent ( ) const {
-	return content;
+	return m_content;
 }
 
 template < class SymbolType >
@@ -156,18 +164,18 @@ template < class SymbolType >
 void UnrankedTree < SymbolType >::setTree ( std::tree < SymbolType > data ) {
 	checkAlphabet ( data );
 
-	this->content = std::move ( data );
+	this->m_content = std::move ( data );
 }
 
 template < class SymbolType >
 void UnrankedTree < SymbolType >::operator >>( std::ostream & out ) const {
-	out << "(UnrankedTree " << this->content << ")";
+	out << "(UnrankedTree " << this->m_content << ")";
 }
 
 template < class SymbolType >
 int UnrankedTree < SymbolType >::compare ( const UnrankedTree & other ) const {
-	auto first = std::tie ( content, getAlphabet() );
-	auto second = std::tie ( other.content, other.getAlphabet() );
+	auto first = std::tie ( m_content, getAlphabet() );
+	auto second = std::tie ( other.m_content, other.getAlphabet() );
 
 	static std::compare < decltype ( first ) > comp;
 
@@ -176,7 +184,7 @@ int UnrankedTree < SymbolType >::compare ( const UnrankedTree & other ) const {
 
 template < class SymbolType >
 void UnrankedTree < SymbolType >::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
+	m_content.nicePrint ( os );
 }
 
 template < class SymbolType >
@@ -218,8 +226,8 @@ template < class SymbolType >
 class ComponentConstraint< ::tree::UnrankedTree < SymbolType >, SymbolType, ::tree::GeneralAlphabet > {
 public:
 	static bool used ( const ::tree::UnrankedTree < SymbolType > & tree, const SymbolType & symbol ) {
-		const std::tree<SymbolType>& content = tree.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end();
+		const std::tree<SymbolType>& m_content = tree.getContent ( );
+		return std::find(m_content.prefix_begin(), m_content.prefix_end(), symbol) != m_content.prefix_end();
 	}
 
 	static bool available ( const ::tree::UnrankedTree < SymbolType > &, const SymbolType & ) {
-- 
GitLab