From 6b80ecd432dca6843fe673478439ad8b93b324b7 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 25 May 2015 14:32:00 +0200
Subject: [PATCH] +PrefixRankedPattern

---
 acast2/src/acast.cpp                          |   4 +-
 .../src/arbology/exact/ExactSubtreeMatch.cpp  |  10 +-
 .../src/arbology/exact/ExactSubtreeMatch.h    |   5 +-
 .../exact/ExactSubtreeMatchingAutomaton.cpp   |  10 +-
 .../exact/ExactSubtreeMatchingAutomaton.h     |   5 +-
 alib2data/src/XmlApi.cpp                      |  33 +++-
 alib2data/src/XmlApi.hpp                      |  19 ++-
 alib2data/src/object/ObjectBase.h             |   5 +-
 alib2data/src/string/LinearString.cpp         |   2 +-
 alib2data/src/string/LinearString.h           |   4 +-
 alib2data/src/tree/TreeFeatures.h             |   2 +-
 alib2data/src/tree/TreeFromRawParser.cpp      |   6 +-
 alib2data/src/tree/TreeFromXMLParser.cpp      |  35 ++--
 alib2data/src/tree/TreeFromXMLParser.h        |   3 +-
 alib2data/src/tree/TreeToRawComposer.cpp      |   8 +-
 alib2data/src/tree/TreeToRawComposer.h        |   5 +-
 alib2data/src/tree/TreeToXMLComposer.cpp      |  20 ++-
 alib2data/src/tree/TreeToXMLComposer.h        |   6 +-
 .../src/tree/ranked/PrefixRankedPattern.cpp   | 127 ++++++++++++++
 .../src/tree/ranked/PrefixRankedPattern.h     |  79 +++++++++
 ...ankedNotation.cpp => PrefixRankedTree.cpp} |  36 ++--
 ...fixRankedNotation.h => PrefixRankedTree.h} |  22 +--
 alib2data/test-src/tree/PatternTest.cpp       | 158 ++++++++++++++++++
 alib2data/test-src/tree/PatternTest.h         |  24 +++
 alib2data/test-src/tree/TreeTest.cpp          | 100 -----------
 alib2data/test-src/tree/TreeTest.h            |   5 -
 26 files changed, 545 insertions(+), 188 deletions(-)
 create mode 100644 alib2data/src/tree/ranked/PrefixRankedPattern.cpp
 create mode 100644 alib2data/src/tree/ranked/PrefixRankedPattern.h
 rename alib2data/src/tree/ranked/{PrefixRankedNotation.cpp => PrefixRankedTree.cpp} (66%)
 rename alib2data/src/tree/ranked/{PrefixRankedNotation.h => PrefixRankedTree.h} (62%)
 create mode 100644 alib2data/test-src/tree/PatternTest.cpp
 create mode 100644 alib2data/test-src/tree/PatternTest.h

diff --git a/acast2/src/acast.cpp b/acast2/src/acast.cpp
index 035bb484fb..706dd080c0 100644
--- a/acast2/src/acast.cpp
+++ b/acast2/src/acast.cpp
@@ -46,8 +46,8 @@ int main(int argc, char** argv) {
 		/*alib::Object object = alib::XmlDataFactory::fromTokens<alib::Object>(tokens);
 		CastBaseVisitor::do_cast(type.getValue(), object.getData());*/
 
-		if(alib::XmlDataFactory::first<tree::PrefixRankedNotation>(tokens) && std::is_same_type<string::LinearString>(type.getValue().c_str())) {
-			tree::PrefixRankedNotation tree = alib::XmlDataFactory::fromTokens<tree::PrefixRankedNotation>(tokens);
+		if(alib::XmlDataFactory::first<tree::PrefixRankedTree>(tokens) && std::is_same_type<string::LinearString>(type.getValue().c_str())) {
+			tree::PrefixRankedTree tree = alib::XmlDataFactory::fromTokens<tree::PrefixRankedTree>(tokens);
 			alib::XmlDataFactory::toStdout(string::LinearString(tree));
 		} else if(alib::XmlDataFactory::first<automaton::Automaton>(tokens)) {
 			automaton::Automaton automaton = alib::XmlDataFactory::fromTokens<automaton::Automaton>(tokens);
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
index 51eb253753..79355958ce 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
@@ -8,7 +8,7 @@
 #include "ExactSubtreeMatch.h"
 #include <exception/AlibException.h>
 #include <tree/ranked/RankedTree.h>
-#include <tree/ranked/PrefixRankedNotation.h>
+#include <tree/ranked/PrefixRankedTree.h>
 #include <tree/unranked/UnrankedTree.h>
 
 #include <deque>
@@ -72,7 +72,7 @@ std::set<unsigned> ExactSubtreeMatch::match(const tree::RankedTree& subject, con
 	return occ;
 }
 
-std::set<unsigned> ExactSubtreeMatch::match(const tree::PrefixRankedNotation& subject, const tree::PrefixRankedNotation& pattern) {
+std::set<unsigned> ExactSubtreeMatch::match(const tree::PrefixRankedTree& subject, const tree::PrefixRankedTree& pattern) {
 	std::set<unsigned> occ;
 	for(unsigned i = 0; i <= subject.getContent().size() - pattern.getContent().size(); i++) {
 		unsigned j = 0;
@@ -100,11 +100,15 @@ void ExactSubtreeMatch::Visit(void*, const tree::RankedPattern&, const tree::Ran
 	throw exception::AlibException("Unsupported tree type RankedPattern");
 }
 
-void ExactSubtreeMatch::Visit(void* data, const tree::PrefixRankedNotation& subject, const tree::PrefixRankedNotation& pattern) const {
+void ExactSubtreeMatch::Visit(void* data, const tree::PrefixRankedTree& subject, const tree::PrefixRankedTree& pattern) const {
 	std::set<unsigned> & res = *((std::set<unsigned>*) data);
 	res = this->match(subject, pattern);
 }
 
+void ExactSubtreeMatch::Visit(void*, const tree::PrefixRankedPattern&, const tree::PrefixRankedPattern&) const {
+	throw exception::AlibException("Unsupported tree type PrefixRankedPattern");
+}
+
 void ExactSubtreeMatch::Visit(void*, const tree::UnrankedPattern&, const tree::UnrankedPattern&) const {
 	throw exception::AlibException("Unsupported tree type UnrankedPattern");
 }
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatch.h b/alib2algo/src/arbology/exact/ExactSubtreeMatch.h
index ba76c43842..e6ef6f2cdb 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatch.h
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatch.h
@@ -30,7 +30,7 @@ public:
 
 	static std::set<unsigned> match(const tree::UnrankedTree& subject, const tree::UnrankedTree& pattern);
 	static std::set<unsigned> match(const tree::RankedTree& subject, const tree::RankedTree& pattern);
-	static std::set<unsigned> match(const tree::PrefixRankedNotation& subject, const tree::PrefixRankedNotation& pattern);
+	static std::set<unsigned> match(const tree::PrefixRankedTree& subject, const tree::PrefixRankedTree& pattern);
 private:
 	static bool matchHelper(const tree::UnrankedNode& subject, const tree::UnrankedNode& pattern);
 	static bool matchHelper(const tree::RankedNode& subject, const tree::RankedNode& pattern);
@@ -41,7 +41,8 @@ private:
 	void Visit(void*, const tree::UnrankedTree& subject, const tree::UnrankedTree& pattern) const;
 	void Visit(void*, const tree::RankedTree& subject, const tree::RankedTree& pattern) const;
 	void Visit(void*, const tree::RankedPattern& subject, const tree::RankedPattern& pattern) const;
-	void Visit(void*, const tree::PrefixRankedNotation& subject, const tree::PrefixRankedNotation& pattern) const;
+	void Visit(void*, const tree::PrefixRankedTree& subject, const tree::PrefixRankedTree& pattern) const;
+	void Visit(void*, const tree::PrefixRankedPattern& subject, const tree::PrefixRankedPattern& pattern) const;
 	void Visit(void*, const tree::UnrankedPattern& subject, const tree::UnrankedPattern& pattern) const;
 
 	static const ExactSubtreeMatch EXACT_SUBTREE_MATCH;
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
index b47a60a222..fae786a269 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
@@ -7,7 +7,7 @@
 
 #include "ExactSubtreeMatchingAutomaton.h"
 #include <exception/AlibException.h>
-#include <tree/ranked/PrefixRankedNotation.h>
+#include <tree/ranked/PrefixRankedTree.h>
 
 #include <deque>
 
@@ -23,7 +23,7 @@ automaton::Automaton ExactSubtreeMatchingAutomaton::construct(const tree::Tree&
 	return res;
 }
 
-automaton::InputDrivenNPDA ExactSubtreeMatchingAutomaton::construct(const tree::PrefixRankedNotation& pattern) {
+automaton::InputDrivenNPDA ExactSubtreeMatchingAutomaton::construct(const tree::PrefixRankedTree& pattern) {
 	automaton::InputDrivenNPDA res(automaton::State(0), alphabet::symbolFrom('S'));
 
 	for(const alphabet::RankedSymbol& symbol : pattern.getAlphabet()) {
@@ -48,7 +48,7 @@ void ExactSubtreeMatchingAutomaton::Visit(void*, const tree::RankedTree&) const
 	throw exception::AlibException("Unsupported tree type RankedTree");
 }
 
-void ExactSubtreeMatchingAutomaton::Visit(void* data, const tree::PrefixRankedNotation& pattern) const {
+void ExactSubtreeMatchingAutomaton::Visit(void* data, const tree::PrefixRankedTree& pattern) const {
 	automaton::Automaton* & out = *((automaton::Automaton**) data);
 	out = new automaton::Automaton(this->construct(pattern));
 }
@@ -57,6 +57,10 @@ void ExactSubtreeMatchingAutomaton::Visit(void*, const tree::RankedPattern&) con
 	throw exception::AlibException("Unsupported tree type RankedPattern");
 }
 
+void ExactSubtreeMatchingAutomaton::Visit(void*, const tree::PrefixRankedPattern&) const {
+	throw exception::AlibException("Unsupported tree type PrefixRankedPattern");
+}
+
 void ExactSubtreeMatchingAutomaton::Visit(void*, const tree::UnrankedTree&) const {
 	throw exception::AlibException("Unsupported tree type UnrankedTree");
 }
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.h b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.h
index bcc68f34b3..0f7b47bdc6 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.h
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.h
@@ -26,11 +26,12 @@ public:
 	 */
 	static automaton::Automaton construct(const tree::Tree& pattern);
 
-	static automaton::InputDrivenNPDA construct(const tree::PrefixRankedNotation& pattern);
+	static automaton::InputDrivenNPDA construct(const tree::PrefixRankedTree& pattern);
 private:
 	void Visit(void*, const tree::RankedTree& pattern) const;
 	void Visit(void*, const tree::RankedPattern& subject) const;
-	void Visit(void*, const tree::PrefixRankedNotation& pattern) const;
+	void Visit(void*, const tree::PrefixRankedTree& pattern) const;
+	void Visit(void*, const tree::PrefixRankedPattern& pattern) const;
 	void Visit(void*, const tree::UnrankedTree& pattern) const;
 	void Visit(void*, const tree::UnrankedPattern& subject) const;
 
diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 5a4a733da8..7b850fa773 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -107,7 +107,8 @@ const std::string Names::PRIMITIVE_UNSIGNED = "Unsigned";
 const std::string Names::PRIMITIVE_BOOL = "Bool";
 const std::string Names::TREE_RANKED_TREE = "RankedTree";
 const std::string Names::TREE_RANKED_PATTERN = "RankedPattern";
-const std::string Names::TREE_PREFIX_RANKED_NOTATION = "PrefixRankedNotation";
+const std::string Names::TREE_PREFIX_RANKED_TREE = "PrefixRankedTree";
+const std::string Names::TREE_PREFIX_RANKED_PATTERN = "PrefixRankedPattern";
 const std::string Names::TREE_UNRANKED_TREE = "UnrankedTree";
 const std::string Names::TREE_UNRANKED_PATTERN = "UnrankedPattern";
 
@@ -1126,15 +1127,27 @@ void xmlApi<tree::Tree>::compose(std::deque<sax::Token>& output, const tree::Tre
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
-tree::PrefixRankedNotation xmlApi<tree::PrefixRankedNotation>::parse(std::deque<sax::Token>& input) {
-	return FromXMLParsers::treeParser.parsePrefixRankedNotation(input);
+tree::PrefixRankedTree xmlApi<tree::PrefixRankedTree>::parse(std::deque<sax::Token>& input) {
+	return FromXMLParsers::treeParser.parsePrefixRankedTree(input);
 }
 
-bool xmlApi<tree::PrefixRankedNotation>::first(const std::deque<sax::Token>& input) {
-	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_NOTATION);
+bool xmlApi<tree::PrefixRankedTree>::first(const std::deque<sax::Token>& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_TREE);
 }
 
-void xmlApi<tree::PrefixRankedNotation>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedNotation& data) {
+void xmlApi<tree::PrefixRankedTree>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedTree& data) {
+	ToXMLComposers::treeComposer.compose(output, data);
+}
+
+tree::PrefixRankedPattern xmlApi<tree::PrefixRankedPattern>::parse(std::deque<sax::Token>& input) {
+	return FromXMLParsers::treeParser.parsePrefixRankedPattern(input);
+}
+
+bool xmlApi<tree::PrefixRankedPattern>::first(const std::deque<sax::Token>& input) {
+	return sax::FromXMLParserHelper::isToken(input, sax::Token::TokenType::START_ELEMENT, Names::TREE_PREFIX_RANKED_TREE);
+}
+
+void xmlApi<tree::PrefixRankedPattern>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data) {
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
@@ -1462,8 +1475,12 @@ void ToXMLComposers::Visit(void* data, const tree::RankedPattern& tree) const {
 	xmlApi<tree::RankedPattern>::compose(*((std::deque<sax::Token>*) data), tree);
 }
 
-void ToXMLComposers::Visit(void* data, const tree::PrefixRankedNotation& tree) const {
-	xmlApi<tree::PrefixRankedNotation>::compose(*((std::deque<sax::Token>*) data), tree);
+void ToXMLComposers::Visit(void* data, const tree::PrefixRankedTree& tree) const {
+	xmlApi<tree::PrefixRankedTree>::compose(*((std::deque<sax::Token>*) data), tree);
+}
+
+void ToXMLComposers::Visit(void* data, const tree::PrefixRankedPattern& tree) const {
+	xmlApi<tree::PrefixRankedPattern>::compose(*((std::deque<sax::Token>*) data), tree);
 }
 
 void ToXMLComposers::Visit(void* data, const tree::UnrankedTree& tree) const {
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index 42df224eac..51796d6487 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -108,7 +108,8 @@ public:
 	const static std::string PRIMITIVE_BOOL;
 	const static std::string TREE_RANKED_TREE;
 	const static std::string TREE_RANKED_PATTERN;
-	const static std::string TREE_PREFIX_RANKED_NOTATION;
+	const static std::string TREE_PREFIX_RANKED_TREE;
+	const static std::string TREE_PREFIX_RANKED_PATTERN;
 	const static std::string TREE_UNRANKED_TREE;
 	const static std::string TREE_UNRANKED_PATTERN;
 
@@ -766,10 +767,17 @@ struct xmlApi<tree::RankedPattern> {
 };
 
 template<>
-struct xmlApi<tree::PrefixRankedNotation> {
-	static tree::PrefixRankedNotation parse(std::deque<sax::Token>& input);
+struct xmlApi<tree::PrefixRankedTree> {
+	static tree::PrefixRankedTree parse(std::deque<sax::Token>& input);
 	static bool first(const std::deque<sax::Token>& input);
-	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedNotation& data);
+	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedTree& data);
+};
+
+template<>
+struct xmlApi<tree::PrefixRankedPattern> {
+	static tree::PrefixRankedPattern parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data);
 };
 
 template<>
@@ -907,7 +915,8 @@ private:
 
 	void Visit(void*, const tree::RankedTree& tree) const;
 	void Visit(void*, const tree::RankedPattern& tree) const;
-	void Visit(void*, const tree::PrefixRankedNotation& tree) const;
+	void Visit(void*, const tree::PrefixRankedTree& tree) const;
+	void Visit(void*, const tree::PrefixRankedPattern& tree) const;
 	void Visit(void*, const tree::UnrankedTree& tree) const;
 	void Visit(void*, const tree::UnrankedPattern& tree) const;
 
diff --git a/alib2data/src/object/ObjectBase.h b/alib2data/src/object/ObjectBase.h
index c5ca3a2d39..55e29d6474 100644
--- a/alib2data/src/object/ObjectBase.h
+++ b/alib2data/src/object/ObjectBase.h
@@ -139,7 +139,8 @@ namespace tree {
 
 class RankedTree;
 class RankedPattern;
-class PrefixRankedNotation;
+class PrefixRankedTree;
+class PrefixRankedPattern;
 class UnrankedTree;
 class UnrankedPattern;
 
@@ -151,7 +152,7 @@ namespace alib {
 
 class ObjectBase;
 
-typedef std::tuple< tree::RankedTree, tree::RankedPattern, tree::PrefixRankedNotation, tree::UnrankedTree, tree::UnrankedPattern
+typedef std::tuple< tree::RankedTree, tree::RankedPattern, tree::PrefixRankedTree, tree::PrefixRankedPattern, tree::UnrankedTree, tree::UnrankedPattern
 	> TreeTypes;
 
 typedef std::tuple< primitive::String, primitive::Integer, primitive::Character, primitive::Unsigned, primitive::Bool
diff --git a/alib2data/src/string/LinearString.cpp b/alib2data/src/string/LinearString.cpp
index 67ad8f6a46..8f8c193961 100644
--- a/alib2data/src/string/LinearString.cpp
+++ b/alib2data/src/string/LinearString.cpp
@@ -20,7 +20,7 @@ LinearString::LinearString() {
 
 }
 
-LinearString::LinearString(const tree::PrefixRankedNotation& tree) {
+LinearString::LinearString(const tree::PrefixRankedTree& tree) {
 	for(const alphabet::RankedSymbol& symbol : tree.getAlphabet()) {
 		this->alphabet.insert(alphabet::Symbol(std::move(symbol)));
 	}
diff --git a/alib2data/src/string/LinearString.h b/alib2data/src/string/LinearString.h
index 7929684928..9ea29723b8 100644
--- a/alib2data/src/string/LinearString.h
+++ b/alib2data/src/string/LinearString.h
@@ -16,7 +16,7 @@
 #include "StringBase.h"
 #include "common/StringAlphabet.h"
 #include "Epsilon.h"
-#include "../tree/ranked/PrefixRankedNotation.h"
+#include "../tree/ranked/PrefixRankedTree.h"
 
 namespace string {
 
@@ -29,7 +29,7 @@ class LinearString : public std::acceptor<LinearString, VisitableStringBase, std
 
 public:
 	explicit LinearString();
-	explicit LinearString(const tree::PrefixRankedNotation& tree);
+	explicit LinearString(const tree::PrefixRankedTree& tree);
 	explicit LinearString(std::set<alphabet::Symbol> alphabet, std::vector<alphabet::Symbol> data);
 	explicit LinearString(std::vector<alphabet::Symbol> data);
 	explicit LinearString(const std::string& string);
diff --git a/alib2data/src/tree/TreeFeatures.h b/alib2data/src/tree/TreeFeatures.h
index 5aafc5bf79..33bf89dc90 100644
--- a/alib2data/src/tree/TreeFeatures.h
+++ b/alib2data/src/tree/TreeFeatures.h
@@ -11,7 +11,7 @@
 namespace tree {
 
 enum class FEATURES {
-	RANKED_TREE, RANKED_PATTERN, PREFIX_RANKED_NOTATION, UNRANKED_TREE, UNRANKED_PATTERN
+	RANKED_TREE, RANKED_PATTERN, PREFIX_RANKED_TREE, PREFIX_RANKED_PATTERN, UNRANKED_TREE, UNRANKED_PATTERN
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/TreeFromRawParser.cpp b/alib2data/src/tree/TreeFromRawParser.cpp
index 8c0d712556..f3c2249391 100644
--- a/alib2data/src/tree/TreeFromRawParser.cpp
+++ b/alib2data/src/tree/TreeFromRawParser.cpp
@@ -8,7 +8,7 @@
 #include "TreeFromRawParser.h"
 #include "TreeException.h"
 #include "ranked/RankedTree.h"
-#include "ranked/PrefixRankedNotation.h"
+#include "ranked/PrefixRankedTree.h"
 #include "unranked/UnrankedTree.h"
 #include "../alphabet/LabeledSymbol.h"
 #include "../label/Label.h"
@@ -16,7 +16,7 @@
 namespace tree {
 
 Tree TreeFromRawParser::parseTree(std::deque<sax::Token>& input) const {
-	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::PREFIX_RANKED_NOTATION, FEATURES::UNRANKED_TREE}));
+	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::PREFIX_RANKED_TREE, FEATURES::UNRANKED_TREE}));
 }
 
 Tree TreeFromRawParser::parseTree(std::deque<sax::Token> &input, const std::set<FEATURES>& features) const {
@@ -33,7 +33,7 @@ Tree TreeFromRawParser::parseTree(std::deque<sax::Token> &input, const std::set<
 	delete root;
 	if(features.count(FEATURES::UNRANKED_TREE)) return Tree{tree};
 
-	if(features.count(FEATURES::PREFIX_RANKED_NOTATION)) return Tree{PrefixRankedNotation{RankedTree{tree}}};
+	if(features.count(FEATURES::PREFIX_RANKED_TREE)) return Tree{PrefixRankedTree{RankedTree{tree}}};
 
 	if(features.count(FEATURES::RANKED_TREE)) return Tree{RankedTree{tree}};
 
diff --git a/alib2data/src/tree/TreeFromXMLParser.cpp b/alib2data/src/tree/TreeFromXMLParser.cpp
index 2681c537ff..650b0845c4 100644
--- a/alib2data/src/tree/TreeFromXMLParser.cpp
+++ b/alib2data/src/tree/TreeFromXMLParser.cpp
@@ -14,7 +14,7 @@
 namespace tree {
 
 Tree TreeFromXMLParser::parseTree(std::deque<sax::Token> &input) const {
-	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::RANKED_PATTERN, FEATURES::UNRANKED_TREE, FEATURES::UNRANKED_PATTERN, FEATURES::PREFIX_RANKED_NOTATION}));
+	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::RANKED_PATTERN, FEATURES::UNRANKED_TREE, FEATURES::UNRANKED_PATTERN, FEATURES::PREFIX_RANKED_TREE}));
 }
 
 Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
@@ -30,11 +30,14 @@ Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<
 	} else if(alib::xmlApi<UnrankedPattern>::first(input)) {
 		if(!features.count(FEATURES::UNRANKED_PATTERN)) throw exception::AlibException();
 		return Tree(parseUnrankedPattern(input));
-	} else if(alib::xmlApi<PrefixRankedNotation>::first(input)) {
-		if(!features.count(FEATURES::PREFIX_RANKED_NOTATION)) throw exception::AlibException();
-		return Tree(parsePrefixRankedNotation(input));
+	} else if(alib::xmlApi<PrefixRankedTree>::first(input)) {
+		if(!features.count(FEATURES::PREFIX_RANKED_TREE)) throw exception::AlibException();
+		return Tree(parsePrefixRankedTree(input));
+	} else if(alib::xmlApi<PrefixRankedPattern>::first(input)) {
+		if(!features.count(FEATURES::PREFIX_RANKED_PATTERN)) throw exception::AlibException();
+		return Tree(parsePrefixRankedPattern(input));
 	} else
-		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedNotation / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
 RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>& input) const {
@@ -60,14 +63,26 @@ RankedTree TreeFromXMLParser::parseRankedTree(std::deque<sax::Token>& input) con
 	return tree;
 }
 
-PrefixRankedNotation TreeFromXMLParser::parsePrefixRankedNotation(std::deque<sax::Token>& input) const {
-	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_NOTATION);
+PrefixRankedTree TreeFromXMLParser::parsePrefixRankedTree(std::deque<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_TREE);
 
 	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
 	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
-	PrefixRankedNotation tree(std::move(rankedAlphabet), std::move(data));
+	PrefixRankedTree tree(std::move(rankedAlphabet), std::move(data));
 
-	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_NOTATION);
+	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_TREE);
+	return tree;
+}
+
+PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_PATTERN);
+
+	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
+	PrefixRankedPattern tree(subtreeWildcard, std::move(rankedAlphabet), std::move(data));
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_PATTERN);
 	return tree;
 }
 
@@ -159,7 +174,7 @@ UnrankedNode * TreeFromXMLParser::parseUnrankedNode(std::deque<sax::Token> &inpu
 }
 
 bool TreeFromXMLParser::first(const std::deque<sax::Token>& input) const {
-	if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<RankedPattern>::first(input) || alib::xmlApi<PrefixRankedNotation>::first(input) || alib::xmlApi<UnrankedTree>::first(input) || alib::xmlApi<UnrankedPattern>::first(input)) {
+	if (alib::xmlApi<RankedTree>::first(input) || alib::xmlApi<RankedPattern>::first(input) || alib::xmlApi<PrefixRankedTree>::first(input)  || alib::xmlApi<PrefixRankedPattern>::first(input) || alib::xmlApi<UnrankedTree>::first(input) || alib::xmlApi<UnrankedPattern>::first(input)) {
 		return true;
 	} else {
 		return false;
diff --git a/alib2data/src/tree/TreeFromXMLParser.h b/alib2data/src/tree/TreeFromXMLParser.h
index 20bd15ef3d..54ded27432 100644
--- a/alib2data/src/tree/TreeFromXMLParser.h
+++ b/alib2data/src/tree/TreeFromXMLParser.h
@@ -50,7 +50,8 @@ private:
 
 	RankedTree parseRankedTree(std::deque<sax::Token>& input) const;
 	RankedPattern parseRankedPattern(std::deque<sax::Token>& input) const;
-	PrefixRankedNotation parsePrefixRankedNotation(std::deque<sax::Token>& input) const;
+	PrefixRankedTree parsePrefixRankedTree(std::deque<sax::Token>& input) const;
+	PrefixRankedPattern parsePrefixRankedPattern(std::deque<sax::Token>& input) const;
 	UnrankedTree parseUnrankedTree(std::deque<sax::Token>& input) const;
 	UnrankedPattern parseUnrankedPattern(std::deque<sax::Token>& input) const;
 
diff --git a/alib2data/src/tree/TreeToRawComposer.cpp b/alib2data/src/tree/TreeToRawComposer.cpp
index c70ae6b0d9..adfb0d0ca5 100644
--- a/alib2data/src/tree/TreeToRawComposer.cpp
+++ b/alib2data/src/tree/TreeToRawComposer.cpp
@@ -24,7 +24,7 @@ void TreeToRawComposer::compose(std::deque<sax::Token>& out, const RankedTree& t
 	composeNode(out, tree.getRoot());
 }
 
-void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedNotation& tree) const {
+void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const {
 	unsigned i = 0;
 	composeNotation(out, i, tree.getContent());
 }
@@ -85,11 +85,15 @@ void TreeToRawComposer::Visit(void*, const RankedPattern&) const {
 	throw tree::TreeException("Cant compose RankedPattern to raw representation");
 }
 
-void TreeToRawComposer::Visit(void* userData, const PrefixRankedNotation& tree) const {
+void TreeToRawComposer::Visit(void* userData, const PrefixRankedTree& tree) const {
 	std::deque<sax::Token> &res = *((std::deque<sax::Token>*) userData);
 	this->compose(res, tree);
 }
 
+void TreeToRawComposer::Visit(void*, const PrefixRankedPattern&) const {
+	throw tree::TreeException("Cant compose PrefixRankedPattern to raw representation");
+}
+
 void TreeToRawComposer::Visit(void* userData, const UnrankedTree& tree) const {
 	std::deque<sax::Token> &res = *((std::deque<sax::Token>*) userData);
 	this->compose(res, tree);
diff --git a/alib2data/src/tree/TreeToRawComposer.h b/alib2data/src/tree/TreeToRawComposer.h
index 3d61de4201..dec349ec69 100644
--- a/alib2data/src/tree/TreeToRawComposer.h
+++ b/alib2data/src/tree/TreeToRawComposer.h
@@ -32,14 +32,15 @@ public:
 
 	void Visit(void*, const RankedTree& tree) const;
 	void Visit(void*, const RankedPattern& tree) const;
-	void Visit(void*, const PrefixRankedNotation& tree) const;
+	void Visit(void*, const PrefixRankedTree& tree) const;
+	void Visit(void*, const PrefixRankedPattern& tree) const;
 	void Visit(void*, const UnrankedTree& tree) const;
 	void Visit(void*, const UnrankedPattern& tree) const;
 
 	void compose(std::deque<sax::Token>& out, const Tree& tree) const;
 
 	void compose(std::deque<sax::Token>& out, const RankedTree& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedNotation& tree) const;
+	void compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const;
 	void compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const;
 
 private:
diff --git a/alib2data/src/tree/TreeToXMLComposer.cpp b/alib2data/src/tree/TreeToXMLComposer.cpp
index 4a7c7fd912..1cbe63378a 100644
--- a/alib2data/src/tree/TreeToXMLComposer.cpp
+++ b/alib2data/src/tree/TreeToXMLComposer.cpp
@@ -61,8 +61,8 @@ void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const RankedPattern
 	out.emplace_back(sax::Token(alib::Names::TREE_RANKED_PATTERN, sax::Token::TokenType::END_ELEMENT));
 }
 
-void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedNotation& tree) const {
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_NOTATION, sax::Token::TokenType::START_ELEMENT));
+void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const {
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_TREE, sax::Token::TokenType::START_ELEMENT));
 
 	composeAlphabet(out, tree.getAlphabet());
 	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
@@ -71,7 +71,21 @@ void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedN
 	}
 	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
 
-	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_NOTATION, sax::Token::TokenType::END_ELEMENT));
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_TREE, sax::Token::TokenType::END_ELEMENT));
+}
+
+void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const {
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_PATTERN, sax::Token::TokenType::START_ELEMENT));
+
+	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
+	composeAlphabet(out, tree.getAlphabet());
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
+	for(const auto& symbol : tree.getContent()) {
+		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
+	}
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_PATTERN, sax::Token::TokenType::END_ELEMENT));
 }
 
 void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const {
diff --git a/alib2data/src/tree/TreeToXMLComposer.h b/alib2data/src/tree/TreeToXMLComposer.h
index 0fda3ae38b..a408f43e7b 100644
--- a/alib2data/src/tree/TreeToXMLComposer.h
+++ b/alib2data/src/tree/TreeToXMLComposer.h
@@ -13,7 +13,8 @@
 #include "Tree.h"
 #include "ranked/RankedTree.h"
 #include "ranked/RankedPattern.h"
-#include "ranked/PrefixRankedNotation.h"
+#include "ranked/PrefixRankedTree.h"
+#include "ranked/PrefixRankedPattern.h"
 #include "unranked/UnrankedTree.h"
 #include "unranked/UnrankedPattern.h"
 #include "../sax/Token.h"
@@ -50,7 +51,8 @@ private:
 
 	void compose(std::deque<sax::Token>& out, const RankedTree& tree) const;
 	void compose(std::deque<sax::Token>& out, const RankedPattern& tree) const;
-	void compose(std::deque<sax::Token>& out, const PrefixRankedNotation& tree) const;
+	void compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const;
+	void compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const;
 	void compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const;
 	void compose(std::deque<sax::Token>& out, const UnrankedPattern& tree) const;
 
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
new file mode 100644
index 0000000000..ac327b54f7
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
@@ -0,0 +1,127 @@
+/*
+ * PrefixRankedPattern.cpp
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "PrefixRankedPattern.h"
+#include "../../exception/AlibException.h"
+
+#include <sstream>
+#include <algorithm>
+#include <deque>
+
+#include "RankedPattern.h"
+
+namespace tree {
+
+PrefixRankedPattern::PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(subtreeWildcard) {
+	this->alphabet = std::move(alphabet);
+	setContent(std::move(data));
+}
+
+PrefixRankedPattern::PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(subtreeWildcard) {
+	arityChecksum(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);
+		}
+	}
+}
+
+TreeBase* PrefixRankedPattern::clone() const {
+	return new PrefixRankedPattern(*this);
+}
+
+TreeBase* 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.");
+
+	if(this->subtreeWildcard == symbol)
+		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtreeWildcard.");
+
+	return alphabet.erase(symbol);
+}
+
+const std::vector<alphabet::RankedSymbol>& PrefixRankedPattern::getContent() const {
+	return this->m_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()));
+
+	if(unknownSymbols.size() > 0)
+		throw exception::AlibException("Input symbols not in the alphabet.");
+
+	this->m_Data = std::move(data);
+}
+
+void PrefixRankedPattern::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+	int arityChecksum = 1;
+	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");
+}
+
+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);
+
+	std::compare<decltype(first)> comp;
+	return comp(first, second);
+}
+
+void PrefixRankedPattern::operator >>(std::ostream& out) const {
+	if( this->isEmpty() ) {
+		out << "(Epsilon)";
+	} else {
+		out << "(PrefixRankedPattern ";
+		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+			out << symbol;
+		out << ")";
+	}
+}
+
+PrefixRankedPattern::operator std::string () const {
+	std::stringstream ss;
+	if( this->isEmpty() ) {
+		ss << "E";
+	} else {
+		ss << "\"";
+		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+			ss << (std::string) symbol;
+		ss << "\"";
+	}
+	return std::move(ss).str();
+}
+
+} /* namespace tree */
+
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
new file mode 100644
index 0000000000..66e02c0263
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -0,0 +1,79 @@
+/*
+ * PrefixRankedPattern.h
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef PREFIX_RANKED_PATTERN_H_
+#define PREFIX_RANKED_PATTERN_H_
+
+#include <set>
+#include <vector>
+
+#include "../../alphabet/RankedSymbol.h"
+#include "../TreeBase.h"
+#include "../common/RankedPatternAlphabet.h"
+
+namespace tree {
+
+/**
+ * Represents regular expression parsed from the XML. Regular expression is stored
+ * as a tree of LinearStringElement.
+ */
+class PrefixRankedPattern : public std::acceptor<PrefixRankedPattern, VisitableTreeBase, std::acceptor<PrefixRankedPattern, alib::VisitableObjectBase, TreeBase> >, public RankedPatternAlphabet {
+	std::vector<alphabet::RankedSymbol> m_Data;
+
+public:
+	explicit PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedPattern(alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedPattern(const RankedPattern& tree);
+
+	virtual TreeBase* clone() const;
+	virtual TreeBase* plunder() &&;
+
+	virtual bool removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol);
+
+	/**
+	 * @return List of symbols forming tree (const version).
+	 */
+	const std::vector<alphabet::RankedSymbol>& getContent() const;
+
+	void setContent(std::vector<alphabet::RankedSymbol> data);
+
+	void arityChecksum(const std::vector<alphabet::RankedSymbol>& data);
+	/**
+	 * @return true if tree is an empty word (vector length is 0)
+	 */
+	bool isEmpty() const;
+
+	virtual int compare(const ObjectBase& other) const {
+		return -other.compare(*this);
+	}
+
+	virtual int compare(const PrefixRankedPattern& other) const;
+
+	virtual void operator >>(std::ostream& out) const;
+
+	virtual explicit operator std::string() const;
+
+	virtual int selfTypeId() const {
+		return typeId(*this);
+	}
+};
+
+} /* namespace tree */
+
+namespace std {
+
+template<>
+struct compare<::tree::PrefixRankedPattern> {
+	int operator()(const ::tree::PrefixRankedPattern& first, const ::tree::PrefixRankedPattern& second) const {
+		return first.compare(second);
+	}
+};
+
+} /* namespace std */
+
+#endif /* PREFIX_RANKED_PATTERN_H_ */
+
diff --git a/alib2data/src/tree/ranked/PrefixRankedNotation.cpp b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
similarity index 66%
rename from alib2data/src/tree/ranked/PrefixRankedNotation.cpp
rename to alib2data/src/tree/ranked/PrefixRankedTree.cpp
index 7bdb5e629f..e25bb312a9 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNotation.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
@@ -1,11 +1,11 @@
 /*
- * PrefixRankedNotation.cpp
+ * PrefixRankedTree.cpp
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#include "PrefixRankedNotation.h"
+#include "PrefixRankedTree.h"
 #include "../../exception/AlibException.h"
 
 #include <sstream>
@@ -16,19 +16,19 @@
 
 namespace tree {
 
-PrefixRankedNotation::PrefixRankedNotation(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) {
+PrefixRankedTree::PrefixRankedTree(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) {
 	this->alphabet = std::move(alphabet);
 	setContent(std::move(data));
 }
 
-PrefixRankedNotation::PrefixRankedNotation(std::vector<alphabet::RankedSymbol> data) {
+PrefixRankedTree::PrefixRankedTree(std::vector<alphabet::RankedSymbol> data) {
 	arityChecksum(data);
 
 	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
 	m_Data = std::move(data);
 }
 
-PrefixRankedNotation::PrefixRankedNotation(const RankedTree& tree) {
+PrefixRankedTree::PrefixRankedTree(const RankedTree& tree) {
 	alphabet = tree.getAlphabet();
 	std::deque<const RankedNode*> queue {&tree.getRoot()};
 	while(!queue.empty()) {
@@ -42,26 +42,26 @@ PrefixRankedNotation::PrefixRankedNotation(const RankedTree& tree) {
 	}
 }
 
-TreeBase* PrefixRankedNotation::clone() const {
-	return new PrefixRankedNotation(*this);
+TreeBase* PrefixRankedTree::clone() const {
+	return new PrefixRankedTree(*this);
 }
 
-TreeBase* PrefixRankedNotation::plunder() && {
-	return new PrefixRankedNotation(std::move(*this));
+TreeBase* PrefixRankedTree::plunder() && {
+	return new PrefixRankedTree(std::move(*this));
 }
 
-bool PrefixRankedNotation::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
+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);
 }
 
-const std::vector<alphabet::RankedSymbol>& PrefixRankedNotation::getContent() const {
+const std::vector<alphabet::RankedSymbol>& PrefixRankedTree::getContent() const {
 	return this->m_Data;
 }
 
-void PrefixRankedNotation::setContent(std::vector<alphabet::RankedSymbol> data) {
+void PrefixRankedTree::setContent(std::vector<alphabet::RankedSymbol> data) {
 	arityChecksum(data);
 
 	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
@@ -74,7 +74,7 @@ void PrefixRankedNotation::setContent(std::vector<alphabet::RankedSymbol> data)
 	this->m_Data = std::move(data);
 }
 
-void PrefixRankedNotation::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();
@@ -84,11 +84,11 @@ void PrefixRankedNotation::arityChecksum(const std::vector<alphabet::RankedSymbo
 	if(arityChecksum != 0) throw exception::AlibException("The string does not form a tree");
 }
 
-bool PrefixRankedNotation::isEmpty() const {
+bool PrefixRankedTree::isEmpty() const {
 	return this->m_Data.size() == 0;
 }
 
-int PrefixRankedNotation::compare(const PrefixRankedNotation& other) const {
+int PrefixRankedTree::compare(const PrefixRankedTree& other) const {
 	auto first = std::tie(m_Data, alphabet);
 	auto second = std::tie(other.m_Data, other.alphabet);
 
@@ -96,18 +96,18 @@ int PrefixRankedNotation::compare(const PrefixRankedNotation& other) const {
 	return comp(first, second);
 }
 
-void PrefixRankedNotation::operator >>(std::ostream& out) const {
+void PrefixRankedTree::operator >>(std::ostream& out) const {
 	if( this->isEmpty() ) {
 		out << "(Epsilon)";
 	} else {
-		out << "(PrefixRankedNotation ";
+		out << "(PrefixRankedTree ";
 		for(const alphabet::RankedSymbol& symbol : this->m_Data)
 			out << symbol;
 		out << ")";
 	}
 }
 
-PrefixRankedNotation::operator std::string () const {
+PrefixRankedTree::operator std::string () const {
 	std::stringstream ss;
 	if( this->isEmpty() ) {
 		ss << "E";
diff --git a/alib2data/src/tree/ranked/PrefixRankedNotation.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
similarity index 62%
rename from alib2data/src/tree/ranked/PrefixRankedNotation.h
rename to alib2data/src/tree/ranked/PrefixRankedTree.h
index c3e069d015..0fd27949b6 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNotation.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -1,12 +1,12 @@
 /*
- * PrefixRankedNotation.h
+ * PrefixRankedTree.h
  *
  *  Created on: Nov 23, 2013
  *      Author: Jan Travnicek
  */
 
-#ifndef PREFIX_RANKED_NOTATION_H_
-#define PREFIX_RANKED_NOTATION_H_
+#ifndef PREFIX_RANKED_TREE_H_
+#define PREFIX_RANKED_TREE_H_
 
 #include <set>
 #include <vector>
@@ -21,13 +21,13 @@ namespace tree {
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedNotation : public std::acceptor<PrefixRankedNotation, VisitableTreeBase, std::acceptor<PrefixRankedNotation, alib::VisitableObjectBase, TreeBase> >, public RankedAlphabet {
+class PrefixRankedTree : public std::acceptor<PrefixRankedTree, VisitableTreeBase, std::acceptor<PrefixRankedTree, alib::VisitableObjectBase, TreeBase> >, public RankedAlphabet {
 	std::vector<alphabet::RankedSymbol> m_Data;
 
 public:
-	explicit PrefixRankedNotation(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data);
-	explicit PrefixRankedNotation(std::vector<alphabet::RankedSymbol> data);
-	explicit PrefixRankedNotation(const RankedTree& tree);
+	explicit PrefixRankedTree(std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedTree(std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedTree(const RankedTree& tree);
 
 	virtual TreeBase* clone() const;
 	virtual TreeBase* plunder() &&;
@@ -51,7 +51,7 @@ public:
 		return -other.compare(*this);
 	}
 
-	virtual int compare(const PrefixRankedNotation& other) const;
+	virtual int compare(const PrefixRankedTree& other) const;
 
 	virtual void operator >>(std::ostream& out) const;
 
@@ -67,13 +67,13 @@ public:
 namespace std {
 
 template<>
-struct compare<::tree::PrefixRankedNotation> {
-	int operator()(const ::tree::PrefixRankedNotation& first, const ::tree::PrefixRankedNotation& second) const {
+struct compare<::tree::PrefixRankedTree> {
+	int operator()(const ::tree::PrefixRankedTree& first, const ::tree::PrefixRankedTree& second) const {
 		return first.compare(second);
 	}
 };
 
 } /* namespace std */
 
-#endif /* PREFIX_RANKED_NOTATION_H_ */
+#endif /* PREFIX_RANKED_TREE_H_ */
 
diff --git a/alib2data/test-src/tree/PatternTest.cpp b/alib2data/test-src/tree/PatternTest.cpp
new file mode 100644
index 0000000000..ca379e1638
--- /dev/null
+++ b/alib2data/test-src/tree/PatternTest.cpp
@@ -0,0 +1,158 @@
+#include "PatternTest.h"
+
+#include "sax/SaxParseInterface.h"
+#include "sax/SaxComposeInterface.h"
+
+#include "tree/ranked/RankedPattern.h"
+#include "tree/ranked/PrefixRankedPattern.h"
+
+#include "tree/TreeException.h"
+
+#include "factory/XmlDataFactory.hpp"
+
+#include "alphabet/RankedSymbol.h"
+#include "alphabet/SubtreeWildcardSymbol.h"
+
+
+#define CPPUNIT_IMPLY(x, y) CPPUNIT_ASSERT(!(x) || (y))
+
+CPPUNIT_TEST_SUITE_NAMED_REGISTRATION( PatternTest, "tree" );
+CPPUNIT_TEST_SUITE_REGISTRATION( PatternTest );
+
+void PatternTest::setUp() {
+}
+
+void PatternTest::tearDown() {
+}
+
+void PatternTest::testRankedPatternParser() {
+	const alphabet::RankedSymbol a ('a', 2);
+	const alphabet::RankedSymbol b ('b', 1);
+	const alphabet::RankedSymbol c ('c', 0);
+
+	const alphabet::RankedSymbol S (alphabet::Symbol { alphabet::SubtreeWildcardSymbol {} }, 0);
+	const std::set<alphabet::RankedSymbol> alphabet {a, b, c, S};
+
+	tree::RankedNode * node3 = new tree::RankedNode(c, {});
+	tree::RankedNode * node4 = new tree::RankedNode(S, {});
+	tree::RankedNode * node2 = new tree::RankedNode(b, {node3});
+	tree::RankedNode node1(a, {node2, node4});
+
+	tree::RankedPattern tree(S, alphabet, std::move(node1));
+
+	CPPUNIT_ASSERT( tree == tree );
+	tree.getRoot().nicePrint(std::cout);
+	{
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(tree);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
+
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		tree::RankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::RankedPattern>(tokens2);
+
+		CPPUNIT_ASSERT( tree == tree2 );
+		std::cout << std::endl;
+		tree2.getRoot().nicePrint(std::cout);
+	}
+
+	const alphabet::Symbol ua = alphabet::symbolFrom('a');
+	const alphabet::Symbol ub = alphabet::symbolFrom('b');
+	const alphabet::Symbol uc = alphabet::symbolFrom('c');
+
+	const alphabet::Symbol uS { alphabet::SubtreeWildcardSymbol {} };
+	const std::set<alphabet::Symbol> ualphabet {ua, ub, uc, uS};
+
+	tree::UnrankedNode * unode3 = new tree::UnrankedNode(uc, {});
+	tree::UnrankedNode * unode4 = new tree::UnrankedNode(uS, {});
+	tree::UnrankedNode * unode2 = new tree::UnrankedNode(ub, {unode3});
+	tree::UnrankedNode unode1(ua, {unode2, unode4});
+
+	tree::UnrankedPattern tree2(uS, ualphabet, std::move(unode1));
+
+	tree::UnrankedPattern tree3 (tree );
+
+	CPPUNIT_ASSERT(tree3 == tree2);
+}
+
+void PatternTest::testUnrankedPatternParser() {
+	const alphabet::Symbol a = alphabet::symbolFrom('a');
+	const alphabet::Symbol b = alphabet::symbolFrom('b');
+	const alphabet::Symbol c = alphabet::symbolFrom('c');
+
+	const alphabet::Symbol S { alphabet::SubtreeWildcardSymbol {} };
+	const std::set<alphabet::Symbol> alphabet {a, b, c, S};
+
+	tree::UnrankedNode * node3 = new tree::UnrankedNode(c, {});
+	tree::UnrankedNode * node4 = new tree::UnrankedNode(S, {});
+	tree::UnrankedNode * node2 = new tree::UnrankedNode(b, {node3});
+	tree::UnrankedNode node1(a, {node2, node4});
+
+	tree::UnrankedPattern tree(S, alphabet, std::move(node1));
+
+	CPPUNIT_ASSERT( tree == tree );
+	tree.getRoot().nicePrint(std::cout);
+	{
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(tree);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
+
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		tree::UnrankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedPattern>(tokens2);
+
+		CPPUNIT_ASSERT( tree == tree2 );
+		std::cout << std::endl;
+		tree2.getRoot().nicePrint(std::cout);
+	}
+
+	const alphabet::RankedSymbol ra ('a', 2);
+	const alphabet::RankedSymbol rb ('b', 1);
+	const alphabet::RankedSymbol rc ('c', 0);
+
+	const alphabet::RankedSymbol rS { alphabet::Symbol { alphabet::SubtreeWildcardSymbol {} }, 0};
+	const std::set<alphabet::RankedSymbol> ralphabet {ra, rb, rc, rS};
+
+	tree::RankedNode * rnode3 = new tree::RankedNode(rc, {});
+	tree::RankedNode * rnode4 = new tree::RankedNode(rS, {});
+	tree::RankedNode * rnode2 = new tree::RankedNode(rb, {rnode3});
+	tree::RankedNode rnode1(ra, {rnode2, rnode4});
+
+	tree::RankedPattern tree2(rS, ralphabet, std::move(rnode1));
+
+	tree::RankedPattern tree3 (tree);
+
+	CPPUNIT_ASSERT(tree3 == tree2);
+}
+
+void PatternTest::testPrefixRankedPatternParser() {
+	const alphabet::RankedSymbol a ('a', 2);
+	const alphabet::RankedSymbol b ('b', 1);
+	const alphabet::RankedSymbol c ('c', 0);
+
+	const alphabet::RankedSymbol S (alphabet::Symbol { alphabet::SubtreeWildcardSymbol {} }, 0);
+	const std::set<alphabet::RankedSymbol> alphabet {a, b, c, S};
+
+	tree::RankedNode * node3 = new tree::RankedNode(c, {});
+	tree::RankedNode * node4 = new tree::RankedNode(S, {});
+	tree::RankedNode * node2 = new tree::RankedNode(b, {node3});
+	tree::RankedNode node1(a, {node2, node4});
+
+	tree::RankedPattern pattern(S, alphabet, std::move(node1));
+	tree::PrefixRankedPattern pattern2(pattern);
+
+	CPPUNIT_ASSERT( pattern2 == pattern2 );
+	{
+		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(pattern2);
+		std::string tmp;
+		sax::SaxComposeInterface::printMemory(tmp, tokens);
+
+		std::deque<sax::Token> tokens2;
+		sax::SaxParseInterface::parseMemory(tmp, tokens2);
+		tree::PrefixRankedPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedPattern>(tokens2);
+
+		CPPUNIT_ASSERT( pattern2 == pattern3 );
+		std::cout << std::endl;
+	}
+}
+
diff --git a/alib2data/test-src/tree/PatternTest.h b/alib2data/test-src/tree/PatternTest.h
new file mode 100644
index 0000000000..7dadcd64cf
--- /dev/null
+++ b/alib2data/test-src/tree/PatternTest.h
@@ -0,0 +1,24 @@
+#ifndef PATTERN_TEST_H_
+#define PATTERN_TEST_H_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+class PatternTest : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( PatternTest );
+  CPPUNIT_TEST( testRankedPatternParser );
+  CPPUNIT_TEST( testUnrankedPatternParser );
+  CPPUNIT_TEST( testPrefixRankedPatternParser );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+  void setUp();
+  void tearDown();
+
+  void testRankedPatternParser();
+  void testUnrankedPatternParser();
+
+  void testPrefixRankedPatternParser();
+};
+
+#endif  // PATTERN_TEST_H_
diff --git a/alib2data/test-src/tree/TreeTest.cpp b/alib2data/test-src/tree/TreeTest.cpp
index 66162edd7b..80fcdd3034 100644
--- a/alib2data/test-src/tree/TreeTest.cpp
+++ b/alib2data/test-src/tree/TreeTest.cpp
@@ -377,103 +377,3 @@ void TreeTest::testUnrankedTreeSubtreeSwitch() {
 	CPPUNIT_ASSERT(tree4 == tree1Copy);
 }
 
-void TreeTest::testRankedPatternParser() {
-	const alphabet::RankedSymbol a ('a', 2);
-	const alphabet::RankedSymbol b ('b', 1);
-	const alphabet::RankedSymbol c ('c', 0);
-
-	const alphabet::RankedSymbol S (alphabet::Symbol { alphabet::SubtreeWildcardSymbol {} }, 0);
-	const std::set<alphabet::RankedSymbol> alphabet {a, b, c, S};
-
-	tree::RankedNode * node3 = new tree::RankedNode(c, {});
-	tree::RankedNode * node4 = new tree::RankedNode(S, {});
-	tree::RankedNode * node2 = new tree::RankedNode(b, {node3});
-	tree::RankedNode node1(a, {node2, node4});
-
-	tree::RankedPattern tree(S, alphabet, std::move(node1));
-
-	CPPUNIT_ASSERT( tree == tree );
-	tree.getRoot().nicePrint(std::cout);
-	{
-		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(tree);
-		std::string tmp;
-		sax::SaxComposeInterface::printMemory(tmp, tokens);
-
-		std::deque<sax::Token> tokens2;
-		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::RankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::RankedPattern>(tokens2);
-
-		CPPUNIT_ASSERT( tree == tree2 );
-		std::cout << std::endl;
-		tree2.getRoot().nicePrint(std::cout);
-	}
-
-	const alphabet::Symbol ua = alphabet::symbolFrom('a');
-	const alphabet::Symbol ub = alphabet::symbolFrom('b');
-	const alphabet::Symbol uc = alphabet::symbolFrom('c');
-
-	const alphabet::Symbol uS { alphabet::SubtreeWildcardSymbol {} };
-	const std::set<alphabet::Symbol> ualphabet {ua, ub, uc, uS};
-
-	tree::UnrankedNode * unode3 = new tree::UnrankedNode(uc, {});
-	tree::UnrankedNode * unode4 = new tree::UnrankedNode(uS, {});
-	tree::UnrankedNode * unode2 = new tree::UnrankedNode(ub, {unode3});
-	tree::UnrankedNode unode1(ua, {unode2, unode4});
-
-	tree::UnrankedPattern tree2(uS, ualphabet, std::move(unode1));
-
-	tree::UnrankedPattern tree3 (tree );
-
-	CPPUNIT_ASSERT(tree3 == tree2);
-}
-
-void TreeTest::testUnrankedPatternParser() {
-	const alphabet::Symbol a = alphabet::symbolFrom('a');
-	const alphabet::Symbol b = alphabet::symbolFrom('b');
-	const alphabet::Symbol c = alphabet::symbolFrom('c');
-
-	const alphabet::Symbol S { alphabet::SubtreeWildcardSymbol {} };
-	const std::set<alphabet::Symbol> alphabet {a, b, c, S};
-
-	tree::UnrankedNode * node3 = new tree::UnrankedNode(c, {});
-	tree::UnrankedNode * node4 = new tree::UnrankedNode(S, {});
-	tree::UnrankedNode * node2 = new tree::UnrankedNode(b, {node3});
-	tree::UnrankedNode node1(a, {node2, node4});
-
-	tree::UnrankedPattern tree(S, alphabet, std::move(node1));
-
-	CPPUNIT_ASSERT( tree == tree );
-	tree.getRoot().nicePrint(std::cout);
-	{
-		std::deque<sax::Token> tokens = alib::XmlDataFactory::toTokens(tree);
-		std::string tmp;
-		sax::SaxComposeInterface::printMemory(tmp, tokens);
-
-		std::deque<sax::Token> tokens2;
-		sax::SaxParseInterface::parseMemory(tmp, tokens2);
-		tree::UnrankedPattern tree2 = alib::XmlDataFactory::fromTokens<tree::UnrankedPattern>(tokens2);
-
-		CPPUNIT_ASSERT( tree == tree2 );
-		std::cout << std::endl;
-		tree2.getRoot().nicePrint(std::cout);
-	}
-
-	const alphabet::RankedSymbol ra ('a', 2);
-	const alphabet::RankedSymbol rb ('b', 1);
-	const alphabet::RankedSymbol rc ('c', 0);
-
-	const alphabet::RankedSymbol rS { alphabet::Symbol { alphabet::SubtreeWildcardSymbol {} }, 0};
-	const std::set<alphabet::RankedSymbol> ralphabet {ra, rb, rc, rS};
-
-	tree::RankedNode * rnode3 = new tree::RankedNode(rc, {});
-	tree::RankedNode * rnode4 = new tree::RankedNode(rS, {});
-	tree::RankedNode * rnode2 = new tree::RankedNode(rb, {rnode3});
-	tree::RankedNode rnode1(ra, {rnode2, rnode4});
-
-	tree::RankedPattern tree2(rS, ralphabet, std::move(rnode1));
-
-	tree::RankedPattern tree3 (tree);
-
-	CPPUNIT_ASSERT(tree3 == tree2);
-}
-
diff --git a/alib2data/test-src/tree/TreeTest.h b/alib2data/test-src/tree/TreeTest.h
index 71d0cb4096..842c4a6018 100644
--- a/alib2data/test-src/tree/TreeTest.h
+++ b/alib2data/test-src/tree/TreeTest.h
@@ -14,8 +14,6 @@ class TreeTest : public CppUnit::TestFixture
   CPPUNIT_TEST( testUnrankedTreeCompare );
   CPPUNIT_TEST( testUnrankedTreeSymbolValidityCheck );
   CPPUNIT_TEST( testUnrankedTreeSubtreeSwitch );
-  CPPUNIT_TEST( testRankedPatternParser );
-  CPPUNIT_TEST( testUnrankedPatternParser );
   CPPUNIT_TEST_SUITE_END();
 
 public:
@@ -31,9 +29,6 @@ public:
   void testUnrankedTreeCompare();
   void testUnrankedTreeSymbolValidityCheck();
   void testUnrankedTreeSubtreeSwitch();
-
-  void testRankedPatternParser();
-  void testUnrankedPatternParser();
 };
 
 #endif  // TREE_TEST_H_
-- 
GitLab