From d9b0f34ba7664503983f799a93ab299dd015524f Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Tue, 26 May 2015 09:58:26 +0200
Subject: [PATCH] +PrefixRankedBarPattern

---
 alib2data/src/XmlApi.cpp                      |  17 +++
 alib2data/src/XmlApi.hpp                      |   9 ++
 alib2data/src/object/ObjectBase.h             |   3 +-
 alib2data/src/tree/Tree.cpp                   |  17 ---
 alib2data/src/tree/TreeFeatures.h             |   2 +-
 alib2data/src/tree/TreeFromXMLParser.cpp      |  27 +++-
 alib2data/src/tree/TreeFromXMLParser.h        |   3 +
 alib2data/src/tree/TreeToRawComposer.cpp      |   4 +
 alib2data/src/tree/TreeToRawComposer.h        |   1 +
 alib2data/src/tree/TreeToXMLComposer.cpp      |  21 +++
 alib2data/src/tree/TreeToXMLComposer.h        |   5 +
 .../tree/ranked/PrefixRankedBarPattern.cpp    | 138 ++++++++++++++++++
 .../src/tree/ranked/PrefixRankedBarPattern.h  |  86 +++++++++++
 alib2data/test-src/tree/PatternTest.cpp       |  34 +++++
 alib2data/test-src/tree/PatternTest.h         |   2 +
 15 files changed, 348 insertions(+), 21 deletions(-)
 delete mode 100644 alib2data/src/tree/Tree.cpp
 create mode 100644 alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
 create mode 100644 alib2data/src/tree/ranked/PrefixRankedBarPattern.h

diff --git a/alib2data/src/XmlApi.cpp b/alib2data/src/XmlApi.cpp
index 7b850fa773..ca97ea06b5 100644
--- a/alib2data/src/XmlApi.cpp
+++ b/alib2data/src/XmlApi.cpp
@@ -109,6 +109,7 @@ const std::string Names::TREE_RANKED_TREE = "RankedTree";
 const std::string Names::TREE_RANKED_PATTERN = "RankedPattern";
 const std::string Names::TREE_PREFIX_RANKED_TREE = "PrefixRankedTree";
 const std::string Names::TREE_PREFIX_RANKED_PATTERN = "PrefixRankedPattern";
+const std::string Names::TREE_PREFIX_RANKED_BAR_PATTERN = "PrefixRankedBarPattern";
 const std::string Names::TREE_UNRANKED_TREE = "UnrankedTree";
 const std::string Names::TREE_UNRANKED_PATTERN = "UnrankedPattern";
 
@@ -1151,6 +1152,18 @@ void xmlApi<tree::PrefixRankedPattern>::compose(std::deque<sax::Token>& output,
 	ToXMLComposers::treeComposer.compose(output, data);
 }
 
+tree::PrefixRankedBarPattern xmlApi<tree::PrefixRankedBarPattern>::parse(std::deque<sax::Token>& input) {
+	return FromXMLParsers::treeParser.parsePrefixRankedBarPattern(input);
+}
+
+bool xmlApi<tree::PrefixRankedBarPattern>::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::PrefixRankedBarPattern>::compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarPattern& data) {
+	ToXMLComposers::treeComposer.compose(output, data);
+}
+
 tree::RankedTree xmlApi<tree::RankedTree>::parse(std::deque<sax::Token>& input) {
 	return FromXMLParsers::treeParser.parseRankedTree(input);
 }
@@ -1483,6 +1496,10 @@ void ToXMLComposers::Visit(void* data, const tree::PrefixRankedPattern& tree) co
 	xmlApi<tree::PrefixRankedPattern>::compose(*((std::deque<sax::Token>*) data), tree);
 }
 
+void ToXMLComposers::Visit(void* data, const tree::PrefixRankedBarPattern& tree) const {
+	xmlApi<tree::PrefixRankedBarPattern>::compose(*((std::deque<sax::Token>*) data), tree);
+}
+
 void ToXMLComposers::Visit(void* data, const tree::UnrankedTree& tree) const {
 	xmlApi<tree::UnrankedTree>::compose(*((std::deque<sax::Token>*) data), tree);
 }
diff --git a/alib2data/src/XmlApi.hpp b/alib2data/src/XmlApi.hpp
index 51796d6487..c5b8c1a885 100644
--- a/alib2data/src/XmlApi.hpp
+++ b/alib2data/src/XmlApi.hpp
@@ -110,6 +110,7 @@ public:
 	const static std::string TREE_RANKED_PATTERN;
 	const static std::string TREE_PREFIX_RANKED_TREE;
 	const static std::string TREE_PREFIX_RANKED_PATTERN;
+	const static std::string TREE_PREFIX_RANKED_BAR_PATTERN;
 	const static std::string TREE_UNRANKED_TREE;
 	const static std::string TREE_UNRANKED_PATTERN;
 
@@ -780,6 +781,13 @@ struct xmlApi<tree::PrefixRankedPattern> {
 	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedPattern& data);
 };
 
+template<>
+struct xmlApi<tree::PrefixRankedBarPattern> {
+	static tree::PrefixRankedBarPattern parse(std::deque<sax::Token>& input);
+	static bool first(const std::deque<sax::Token>& input);
+	static void compose(std::deque<sax::Token>& output, const tree::PrefixRankedBarPattern& data);
+};
+
 template<>
 struct xmlApi<tree::UnrankedTree> {
 	static tree::UnrankedTree parse(std::deque<sax::Token>& input);
@@ -917,6 +925,7 @@ private:
 	void Visit(void*, const tree::RankedPattern& tree) const;
 	void Visit(void*, const tree::PrefixRankedTree& tree) const;
 	void Visit(void*, const tree::PrefixRankedPattern& tree) const;
+	void Visit(void*, const tree::PrefixRankedBarPattern& 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 55e29d6474..a86cf283c4 100644
--- a/alib2data/src/object/ObjectBase.h
+++ b/alib2data/src/object/ObjectBase.h
@@ -141,6 +141,7 @@ class RankedTree;
 class RankedPattern;
 class PrefixRankedTree;
 class PrefixRankedPattern;
+class PrefixRankedBarPattern;
 class UnrankedTree;
 class UnrankedPattern;
 
@@ -152,7 +153,7 @@ namespace alib {
 
 class ObjectBase;
 
-typedef std::tuple< tree::RankedTree, tree::RankedPattern, tree::PrefixRankedTree, tree::PrefixRankedPattern, tree::UnrankedTree, tree::UnrankedPattern
+typedef std::tuple< tree::RankedTree, tree::RankedPattern, tree::PrefixRankedTree, tree::PrefixRankedPattern, tree::PrefixRankedBarPattern, tree::UnrankedTree, tree::UnrankedPattern
 	> TreeTypes;
 
 typedef std::tuple< primitive::String, primitive::Integer, primitive::Character, primitive::Unsigned, primitive::Bool
diff --git a/alib2data/src/tree/Tree.cpp b/alib2data/src/tree/Tree.cpp
deleted file mode 100644
index 9eb3b4fbb0..0000000000
--- a/alib2data/src/tree/Tree.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
- * Tree.cpp
- *
- *  Created on: Nov 16, 2014
- *      Author: Stepan Plachy
- */
-
-#include "Tree.h"
-//#include "../label/NextLabel.h"
-//#include "../label/Label.h"
-//#include <climits>
-#include "TreeException.h"
-
-namespace tree {
-
-} /* namespace tree */
-
diff --git a/alib2data/src/tree/TreeFeatures.h b/alib2data/src/tree/TreeFeatures.h
index 33bf89dc90..5b93855249 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_TREE, PREFIX_RANKED_PATTERN, UNRANKED_TREE, UNRANKED_PATTERN
+	RANKED_TREE, RANKED_PATTERN, PREFIX_RANKED_TREE, PREFIX_RANKED_PATTERN, PREFIX_RANKED_BAR_PATTERN, UNRANKED_TREE, UNRANKED_PATTERN
 };
 
 } /* namespace tree */
diff --git a/alib2data/src/tree/TreeFromXMLParser.cpp b/alib2data/src/tree/TreeFromXMLParser.cpp
index 650b0845c4..24209661e2 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_TREE}));
+	return parseTree(input, std::set<FEATURES>({FEATURES::RANKED_TREE, FEATURES::RANKED_PATTERN, FEATURES::UNRANKED_TREE, FEATURES::UNRANKED_PATTERN, FEATURES::PREFIX_RANKED_TREE, FEATURES::PREFIX_RANKED_PATTERN, FEATURES::PREFIX_RANKED_BAR_PATTERN}));
 }
 
 Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<FEATURES>& features) const {
@@ -36,8 +36,11 @@ Tree TreeFromXMLParser::parseTree(std::deque<sax::Token>& input, const std::set<
 	} else if(alib::xmlApi<PrefixRankedPattern>::first(input)) {
 		if(!features.count(FEATURES::PREFIX_RANKED_PATTERN)) throw exception::AlibException();
 		return Tree(parsePrefixRankedPattern(input));
+	} else if(alib::xmlApi<PrefixRankedBarPattern>::first(input)) {
+		if(!features.count(FEATURES::PREFIX_RANKED_BAR_PATTERN)) throw exception::AlibException();
+		return Tree(parsePrefixRankedBarPattern(input));
 	} else
-		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), input.front());
+		throw sax::ParserException(sax::Token("Tree / RankedTree / RankedPattern / PrefixRankedTree / PrefixRankedPattern / PrefixRankedBarPattern / UnrankedTree / UnrankedPattern", sax::Token::TokenType::START_ELEMENT), input.front());
 }
 
 RankedPattern TreeFromXMLParser::parseRankedPattern(std::deque<sax::Token>& input) const {
@@ -86,6 +89,19 @@ PrefixRankedPattern TreeFromXMLParser::parsePrefixRankedPattern(std::deque<sax::
 	return tree;
 }
 
+PrefixRankedBarPattern TreeFromXMLParser::parsePrefixRankedBarPattern(std::deque<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN);
+
+	alphabet::Symbol bar = parseBar(input);
+	alphabet::RankedSymbol subtreeWildcard = parseSubtreeWildcard<alphabet::RankedSymbol>(input);
+	std::set<alphabet::RankedSymbol> rankedAlphabet = parseRankedAlphabet(input);
+	std::vector<alphabet::RankedSymbol> data = parseContentData(input);
+	PrefixRankedBarPattern tree(bar, subtreeWildcard, std::move(rankedAlphabet), std::move(data));
+
+	popToken(input, sax::Token::TokenType::END_ELEMENT, alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN);
+	return tree;
+}
+
 UnrankedPattern TreeFromXMLParser::parseUnrankedPattern(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, alib::Names::TREE_UNRANKED_PATTERN);
 
@@ -109,6 +125,13 @@ UnrankedTree TreeFromXMLParser::parseUnrankedTree(std::deque<sax::Token>& input)
 	return tree;
 }
 
+alphabet::Symbol TreeFromXMLParser::parseBar(std::deque<sax::Token>& input) const {
+	popToken(input, sax::Token::TokenType::START_ELEMENT, "bar");
+	alphabet::Symbol bar(alib::xmlApi<alphabet::Symbol>::parse(input));
+	popToken(input, sax::Token::TokenType::END_ELEMENT, "bar");
+	return bar;
+}
+
 template<class T>
 T TreeFromXMLParser::parseSubtreeWildcard(std::deque<sax::Token>& input) const {
 	popToken(input, sax::Token::TokenType::START_ELEMENT, "subtreeWildcard");
diff --git a/alib2data/src/tree/TreeFromXMLParser.h b/alib2data/src/tree/TreeFromXMLParser.h
index 54ded27432..ef12d04a52 100644
--- a/alib2data/src/tree/TreeFromXMLParser.h
+++ b/alib2data/src/tree/TreeFromXMLParser.h
@@ -42,6 +42,8 @@ private:
 	std::set<alphabet::RankedSymbol> parseRankedAlphabet(std::deque<sax::Token> &input) const;
 	std::set<alphabet::Symbol> parseAlphabet(std::deque<sax::Token> &input) const;
 
+	alphabet::Symbol parseBar(std::deque<sax::Token> &input) const;
+
 	template<class T>
 	T parseSubtreeWildcard(std::deque<sax::Token> &input) const;
 
@@ -52,6 +54,7 @@ private:
 	RankedPattern parseRankedPattern(std::deque<sax::Token>& input) const;
 	PrefixRankedTree parsePrefixRankedTree(std::deque<sax::Token>& input) const;
 	PrefixRankedPattern parsePrefixRankedPattern(std::deque<sax::Token>& input) const;
+	PrefixRankedBarPattern parsePrefixRankedBarPattern(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 adfb0d0ca5..f97cc7c17e 100644
--- a/alib2data/src/tree/TreeToRawComposer.cpp
+++ b/alib2data/src/tree/TreeToRawComposer.cpp
@@ -94,6 +94,10 @@ void TreeToRawComposer::Visit(void*, const PrefixRankedPattern&) const {
 	throw tree::TreeException("Cant compose PrefixRankedPattern to raw representation");
 }
 
+void TreeToRawComposer::Visit(void*, const PrefixRankedBarPattern&) const {
+	throw tree::TreeException("Cant compose PrefixRankedBarPattern 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 dec349ec69..b967f112d1 100644
--- a/alib2data/src/tree/TreeToRawComposer.h
+++ b/alib2data/src/tree/TreeToRawComposer.h
@@ -34,6 +34,7 @@ public:
 	void Visit(void*, const RankedPattern& tree) const;
 	void Visit(void*, const PrefixRankedTree& tree) const;
 	void Visit(void*, const PrefixRankedPattern& tree) const;
+	void Visit(void*, const PrefixRankedBarPattern& tree) const;
 	void Visit(void*, const UnrankedTree& tree) const;
 	void Visit(void*, const UnrankedPattern& tree) const;
 
diff --git a/alib2data/src/tree/TreeToXMLComposer.cpp b/alib2data/src/tree/TreeToXMLComposer.cpp
index 1cbe63378a..2a3caaca76 100644
--- a/alib2data/src/tree/TreeToXMLComposer.cpp
+++ b/alib2data/src/tree/TreeToXMLComposer.cpp
@@ -11,6 +11,12 @@
 
 namespace tree {
 
+void TreeToXMLComposer::composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const {
+	out.emplace_back(sax::Token("bar", sax::Token::TokenType::START_ELEMENT));
+	alib::xmlApi<alphabet::Symbol>::compose(out, symbol);
+	out.emplace_back(sax::Token("bar", sax::Token::TokenType::END_ELEMENT));
+}
+
 template<class T>
 void TreeToXMLComposer::composeSubtreeWildcard(std::deque<sax::Token>& out, const T& symbol) const {
 	out.emplace_back(sax::Token("subtreeWildcard", sax::Token::TokenType::START_ELEMENT));
@@ -74,6 +80,21 @@ void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedT
 	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 PrefixRankedBarPattern& tree) const {
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN, sax::Token::TokenType::START_ELEMENT));
+
+	composeBar(out, tree.getBarSymbol());
+	composeSubtreeWildcard(out, tree.getSubtreeWildcard());
+	composeAlphabet(out, tree.getAlphabet());
+	out.emplace_back("content", sax::Token::TokenType::START_ELEMENT);
+	for(const auto& symbol : tree.getContent()) {
+		alib::xmlApi<alphabet::RankedSymbol>::compose(out, symbol);
+	}
+	out.emplace_back("content", sax::Token::TokenType::END_ELEMENT);
+
+	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_BAR_PATTERN, sax::Token::TokenType::END_ELEMENT));
+}
+
 void TreeToXMLComposer::compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const {
 	out.emplace_back(sax::Token(alib::Names::TREE_PREFIX_RANKED_PATTERN, sax::Token::TokenType::START_ELEMENT));
 
diff --git a/alib2data/src/tree/TreeToXMLComposer.h b/alib2data/src/tree/TreeToXMLComposer.h
index a408f43e7b..06a1f07aea 100644
--- a/alib2data/src/tree/TreeToXMLComposer.h
+++ b/alib2data/src/tree/TreeToXMLComposer.h
@@ -15,6 +15,7 @@
 #include "ranked/RankedPattern.h"
 #include "ranked/PrefixRankedTree.h"
 #include "ranked/PrefixRankedPattern.h"
+#include "ranked/PrefixRankedBarPattern.h"
 #include "unranked/UnrankedTree.h"
 #include "unranked/UnrankedPattern.h"
 #include "../sax/Token.h"
@@ -38,6 +39,9 @@ public:
 private:
 	void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::RankedSymbol>& symbols) const;
 	void composeAlphabet(std::deque<sax::Token>& out, const std::set<alphabet::Symbol>& symbols) const;
+
+	void composeBar(std::deque<sax::Token>& out, const alphabet::Symbol& symbol) const;
+
 	template<class T>
 	void composeSubtreeWildcard(std::deque<sax::Token>& out, const T& symbol) const;
 
@@ -53,6 +57,7 @@ private:
 	void compose(std::deque<sax::Token>& out, const RankedPattern& tree) const;
 	void compose(std::deque<sax::Token>& out, const PrefixRankedTree& tree) const;
 	void compose(std::deque<sax::Token>& out, const PrefixRankedPattern& tree) const;
+	void compose(std::deque<sax::Token>& out, const PrefixRankedBarPattern& tree) const;
 	void compose(std::deque<sax::Token>& out, const UnrankedTree& tree) const;
 	void compose(std::deque<sax::Token>& out, const UnrankedPattern& tree) const;
 
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
new file mode 100644
index 0000000000..0bdbfc0a1e
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.cpp
@@ -0,0 +1,138 @@
+/*
+ * PrefixRankedBarPattern.cpp
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#include "PrefixRankedBarPattern.h"
+#include "../../exception/AlibException.h"
+
+#include <sstream>
+#include <algorithm>
+#include <deque>
+
+#include "RankedPattern.h"
+
+namespace tree {
+
+PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)), bar(std::move(bar)) {
+	this->alphabet = std::move(alphabet);
+	setContent(std::move(data));
+}
+
+PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data) : RankedPatternAlphabet(std::move(subtreeWildcard)), bar(std::move(bar)) {
+	arityChecksum(data);
+
+	alphabet = std::set<alphabet::RankedSymbol>(data.begin(), data.end());
+	m_Data = std::move(data);
+}
+
+PrefixRankedBarPattern::PrefixRankedBarPattern(alphabet::Symbol bar, const RankedPattern& tree) : RankedPatternAlphabet(tree.getSubtreeWildcard()), bar(bar) {
+	toPrefixRankedBar(tree.getRoot());
+	alphabet = std::set<alphabet::RankedSymbol>(m_Data.begin(), m_Data.end());
+}
+
+void PrefixRankedBarPattern::toPrefixRankedBar(const RankedNode& node) {
+	m_Data.push_back(node.getSymbol());
+	for(const RankedNode* child : node.getChildren())
+		toPrefixRankedBar(*child);
+	m_Data.push_back(alphabet::RankedSymbol(bar, node.getSymbol().getRank()));
+}
+
+TreeBase* PrefixRankedBarPattern::clone() const {
+	return new PrefixRankedBarPattern(*this);
+}
+
+TreeBase* PrefixRankedBarPattern::plunder() && {
+	return new PrefixRankedBarPattern(std::move(*this));
+}
+
+bool PrefixRankedBarPattern::removeSymbolFromAlphabet(const alphabet::RankedSymbol & symbol) {
+	if(std::any_of(m_Data.begin(), m_Data.end(), [&](const alphabet::RankedSymbol & s) { return s == symbol; } ) )
+		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is used.");
+
+	if(this->subtreeWildcard == symbol)
+		throw exception::AlibException("Input symbol \"" + (std::string) symbol + "\" is subtreeWildcard.");
+
+	return alphabet.erase(symbol);
+}
+
+const std::vector<alphabet::RankedSymbol>& PrefixRankedBarPattern::getContent() const {
+	return this->m_Data;
+}
+
+void PrefixRankedBarPattern::setContent(std::vector<alphabet::RankedSymbol> data) {
+	arityChecksum(data);
+
+	std::set<alphabet::RankedSymbol> minimalAlphabet(data.begin(), data.end());
+	std::set<alphabet::RankedSymbol> unknownSymbols;
+	std::set_difference(minimalAlphabet.begin(), minimalAlphabet.end(), alphabet.begin(), alphabet.end(), std::inserter(unknownSymbols, unknownSymbols.end()));
+
+	if(unknownSymbols.size() > 0)
+		throw exception::AlibException("Input symbols not in the alphabet.");
+
+	this->m_Data = std::move(data);
+}
+
+const alphabet::Symbol& PrefixRankedBarPattern::getBarSymbol() const {
+	return bar;
+}
+
+void PrefixRankedBarPattern::arityChecksum(const std::vector<alphabet::RankedSymbol>& data) {
+	int arityChecksumTerminals = 1;
+	int arityChecksumBars = 1;
+	int arityChecksumTypes = 0;
+	for(const alphabet::RankedSymbol& symbol : data) {
+		if(symbol.getSymbol() != bar) {
+			arityChecksumTerminals += symbol.getRank().getData();
+			arityChecksumTerminals -= 1;
+			arityChecksumTypes += 1;
+		} else {
+			arityChecksumBars += symbol.getRank().getData();
+			arityChecksumBars -= 1;
+			arityChecksumTypes -= 1;
+		}
+	}
+
+	if(arityChecksumTerminals != 0 || arityChecksumBars != 0 || arityChecksumTypes != 0) throw exception::AlibException("The string does not form a tree");
+}
+
+bool PrefixRankedBarPattern::isEmpty() const {
+	return this->m_Data.size() == 0;
+}
+
+int PrefixRankedBarPattern::compare(const PrefixRankedBarPattern& other) const {
+	auto first = std::tie(m_Data, alphabet);
+	auto second = std::tie(other.m_Data, other.alphabet);
+
+	std::compare<decltype(first)> comp;
+	return comp(first, second);
+}
+
+void PrefixRankedBarPattern::operator >>(std::ostream& out) const {
+	if( this->isEmpty() ) {
+		out << "(Epsilon)";
+	} else {
+		out << "(PrefixRankedBarPattern ";
+		for(const alphabet::RankedSymbol& symbol : this->m_Data)
+			out << symbol;
+		out << ")";
+	}
+}
+
+PrefixRankedBarPattern::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/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
new file mode 100644
index 0000000000..ae5376242c
--- /dev/null
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -0,0 +1,86 @@
+/*
+ * PrefixRankedBarPattern.h
+ *
+ *  Created on: Nov 23, 2013
+ *      Author: Jan Travnicek
+ */
+
+#ifndef PREFIX_RANKED_BAR_PATTERN_H_
+#define PREFIX_RANKED_BAR_PATTERN_H_
+
+#include <set>
+#include <vector>
+
+#include "../../alphabet/RankedSymbol.h"
+#include "../TreeBase.h"
+#include "../common/RankedPatternAlphabet.h"
+#include "RankedNode.h"
+
+namespace tree {
+
+/**
+ * Represents regular expression parsed from the XML. Regular expression is stored
+ * as a tree of LinearStringElement.
+ */
+class PrefixRankedBarPattern : public std::acceptor<PrefixRankedBarPattern, VisitableTreeBase, std::acceptor<PrefixRankedBarPattern, alib::VisitableObjectBase, TreeBase> >, public RankedPatternAlphabet {
+	std::vector<alphabet::RankedSymbol> m_Data;
+
+	alphabet::Symbol bar;
+
+public:
+	explicit PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::RankedSymbol subtreeWildcard, std::set<alphabet::RankedSymbol> alphabet, std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedBarPattern(alphabet::Symbol bar, alphabet::RankedSymbol subtreeWildcard, std::vector<alphabet::RankedSymbol> data);
+	explicit PrefixRankedBarPattern(alphabet::Symbol bar, const RankedPattern& tree);
+
+	void toPrefixRankedBar(const RankedNode& node);
+
+	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);
+
+	const alphabet::Symbol& getBarSymbol() const;
+
+	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 PrefixRankedBarPattern& 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::PrefixRankedBarPattern> {
+	int operator()(const ::tree::PrefixRankedBarPattern& first, const ::tree::PrefixRankedBarPattern& second) const {
+		return first.compare(second);
+	}
+};
+
+} /* namespace std */
+
+#endif /* PREFIX_RANKED_BAR_PATTERN_H_ */
+
diff --git a/alib2data/test-src/tree/PatternTest.cpp b/alib2data/test-src/tree/PatternTest.cpp
index ca379e1638..d56649a30f 100644
--- a/alib2data/test-src/tree/PatternTest.cpp
+++ b/alib2data/test-src/tree/PatternTest.cpp
@@ -5,6 +5,7 @@
 
 #include "tree/ranked/RankedPattern.h"
 #include "tree/ranked/PrefixRankedPattern.h"
+#include "tree/ranked/PrefixRankedBarPattern.h"
 
 #include "tree/TreeException.h"
 
@@ -156,3 +157,36 @@ void PatternTest::testPrefixRankedPatternParser() {
 	}
 }
 
+void PatternTest::testPrefixRankedBarPatternParser() {
+	const alphabet::Symbol bar{alphabet::BarSymbol{}};
+
+	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::PrefixRankedBarPattern pattern2(bar, 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::PrefixRankedBarPattern pattern3 = alib::XmlDataFactory::fromTokens<tree::PrefixRankedBarPattern>(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
index 7dadcd64cf..ee9b57b9f5 100644
--- a/alib2data/test-src/tree/PatternTest.h
+++ b/alib2data/test-src/tree/PatternTest.h
@@ -9,6 +9,7 @@ class PatternTest : public CppUnit::TestFixture
   CPPUNIT_TEST( testRankedPatternParser );
   CPPUNIT_TEST( testUnrankedPatternParser );
   CPPUNIT_TEST( testPrefixRankedPatternParser );
+  CPPUNIT_TEST( testPrefixRankedBarPatternParser );
   CPPUNIT_TEST_SUITE_END();
 
 public:
@@ -19,6 +20,7 @@ public:
   void testUnrankedPatternParser();
 
   void testPrefixRankedPatternParser();
+  void testPrefixRankedBarPatternParser();
 };
 
 #endif  // PATTERN_TEST_H_
-- 
GitLab