From dfecace44eccbfbae0b8a489de0b79bf83710562 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Sun, 9 Oct 2016 22:21:26 +0200
Subject: [PATCH] template RankedNonlinearPatter tree

---
 aaccess2/src/TreeAccess.cpp                   |   4 +-
 aaccess2/src/TreeAccess.h                     |   2 +-
 .../src/arbology/exact/ExactPatternMatch.cpp  |   4 +-
 .../src/arbology/exact/ExactPatternMatch.h    |   2 +-
 .../src/tree/generate/RandomTreeFactory.cpp   |   4 +-
 .../src/tree/generate/RandomTreeFactory.h     |   2 +-
 alib2data/src/tree/TreeFeatures.h             |   1 +
 .../PrefixRankedBarNonlinearPattern.cpp       |   6 +-
 .../ranked/PrefixRankedBarNonlinearPattern.h  |   4 +-
 .../ranked/PrefixRankedNonlinearPattern.cpp   |   4 +-
 .../ranked/PrefixRankedNonlinearPattern.h     |   2 +-
 .../tree/ranked/RankedNonlinearPattern.cpp    | 115 +---------
 .../src/tree/ranked/RankedNonlinearPattern.h  | 203 ++++++++++++++----
 .../tree/unranked/UnrankedNonlinearPattern.h  |   4 +-
 alib2str/src/tree/TreeFromStringParser.cpp    |   4 +-
 arand2/src/arand.cpp                          |   2 +-
 16 files changed, 190 insertions(+), 173 deletions(-)

diff --git a/aaccess2/src/TreeAccess.cpp b/aaccess2/src/TreeAccess.cpp
index 84ad6bd3b9..8ae88c8795 100644
--- a/aaccess2/src/TreeAccess.cpp
+++ b/aaccess2/src/TreeAccess.cpp
@@ -54,7 +54,7 @@ void TreeAccess::access ( tree::RankedPattern < > & tree, const TreeSettings::Se
 
 auto TreeAccessRankedPattern = TreeAccess::RegistratorWrapper < void, tree::RankedPattern < > > ( TreeAccess::access );
 
-void TreeAccess::access ( tree::RankedNonlinearPattern & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
+void TreeAccess::access ( tree::RankedNonlinearPattern < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == TreeSettings::Settings::ALPHABET )
 		return handleComponent < tree::GeneralAlphabet > ( tree, operation, argument );
 
@@ -70,7 +70,7 @@ void TreeAccess::access ( tree::RankedNonlinearPattern & tree, const TreeSetting
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto TreeAccessRankedNonlinearPattern = TreeAccess::RegistratorWrapper < void, tree::RankedNonlinearPattern > ( TreeAccess::access );
+auto TreeAccessRankedNonlinearPattern = TreeAccess::RegistratorWrapper < void, tree::RankedNonlinearPattern < > > ( TreeAccess::access );
 
 void TreeAccess::access ( tree::UnrankedTree < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == TreeSettings::Settings::ALPHABET )
diff --git a/aaccess2/src/TreeAccess.h b/aaccess2/src/TreeAccess.h
index 7d9389e966..ca2ed83be5 100644
--- a/aaccess2/src/TreeAccess.h
+++ b/aaccess2/src/TreeAccess.h
@@ -23,7 +23,7 @@ public:
 
 	static void access ( tree::RankedTree < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
 	static void access ( tree::RankedPattern < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
-	static void access ( tree::RankedNonlinearPattern & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
+	static void access ( tree::RankedNonlinearPattern < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
 	static void access ( tree::UnrankedTree < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
 };
 
diff --git a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
index 75c924c395..9ca72ae379 100644
--- a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
@@ -127,7 +127,7 @@ std::set < unsigned > ExactPatternMatch::match ( const tree::RankedTree < > & su
 
 auto ExactPatternMatchRankedPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < >, tree::RankedPattern < > > ( ExactPatternMatch::match );
 
-std::set < unsigned > ExactPatternMatch::match ( const tree::RankedTree < > & subject, const tree::RankedNonlinearPattern & pattern ) {
+std::set < unsigned > ExactPatternMatch::match ( const tree::RankedTree < > & subject, const tree::RankedNonlinearPattern < > & pattern ) {
 	unsigned i = 0;
 	std::set < unsigned > occ;
 
@@ -137,7 +137,7 @@ std::set < unsigned > ExactPatternMatch::match ( const tree::RankedTree < > & su
 	return occ;
 }
 
-auto ExactPatternMatchRankedNonlinearPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < >, tree::RankedNonlinearPattern > ( ExactPatternMatch::match );
+auto ExactPatternMatchRankedNonlinearPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < >, tree::RankedNonlinearPattern < > > ( ExactPatternMatch::match );
 
 std::set < unsigned > ExactPatternMatch::match ( const tree::PrefixRankedTree & subject, const tree::PrefixRankedPattern & pattern ) {
 	std::vector < int > subjectSubtreeJumpTable = SubtreeJumpTable::compute ( subject );
diff --git a/alib2algo/src/arbology/exact/ExactPatternMatch.h b/alib2algo/src/arbology/exact/ExactPatternMatch.h
index 84f15a2637..995f587179 100644
--- a/alib2algo/src/arbology/exact/ExactPatternMatch.h
+++ b/alib2algo/src/arbology/exact/ExactPatternMatch.h
@@ -31,7 +31,7 @@ public:
 	static std::set < unsigned > match ( const tree::UnrankedTree < > & subject, const tree::UnrankedPattern < > & pattern );
 
 	static std::set < unsigned > match ( const tree::RankedTree < > & subject, const tree::RankedPattern < > & pattern );
-	static std::set < unsigned > match ( const tree::RankedTree < > & subject, const tree::RankedNonlinearPattern & pattern );
+	static std::set < unsigned > match ( const tree::RankedTree < > & subject, const tree::RankedNonlinearPattern < > & pattern );
 
 	static std::set < unsigned > match ( const tree::PrefixRankedTree & subject, const tree::PrefixRankedPattern & pattern );
 	static std::set < unsigned > match ( const tree::PrefixRankedTree & subject, const tree::PrefixRankedNonlinearPattern & pattern );
diff --git a/alib2algo/src/tree/generate/RandomTreeFactory.cpp b/alib2algo/src/tree/generate/RandomTreeFactory.cpp
index f369228ee9..655c0e59c7 100644
--- a/alib2algo/src/tree/generate/RandomTreeFactory.cpp
+++ b/alib2algo/src/tree/generate/RandomTreeFactory.cpp
@@ -357,7 +357,7 @@ RankedPattern < > RandomTreeFactory::generateRankedPattern ( int depth, int node
 	return tree;
 }
 
-RankedNonlinearPattern RandomTreeFactory::generateRankedNonlinearPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, bool singleNonlinearVariable, int maxRank ) {
+RankedNonlinearPattern < > RandomTreeFactory::generateRankedNonlinearPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, bool singleNonlinearVariable, int maxRank ) {
 	Node * root = generateTreeStructure ( depth, nodesCount, maxRank );
 	std::map < int, std::vector < char > > rankedAlphabet;
 
@@ -381,7 +381,7 @@ RankedNonlinearPattern RandomTreeFactory::generateRankedNonlinearPattern ( int d
 	std::ranked_symbol < > subtreeWildcard ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), 0 );
 	treeRankedAlphabet.insert ( subtreeWildcard );
 	treeRankedAlphabet.insert ( nonlinearVariables.begin ( ), nonlinearVariables.end ( ) );
-	RankedNonlinearPattern tree ( std::move ( subtreeWildcard ), nonlinearVariables, treeRankedAlphabet, root->createRankedNonlinearPatternNode ( singleNonlinearVariable ) );
+	RankedNonlinearPattern < > tree ( std::move ( subtreeWildcard ), nonlinearVariables, treeRankedAlphabet, root->createRankedNonlinearPatternNode ( singleNonlinearVariable ) );
 	delete root;
 	return tree;
 }
diff --git a/alib2algo/src/tree/generate/RandomTreeFactory.h b/alib2algo/src/tree/generate/RandomTreeFactory.h
index 26450f365c..10f8d86709 100644
--- a/alib2algo/src/tree/generate/RandomTreeFactory.h
+++ b/alib2algo/src/tree/generate/RandomTreeFactory.h
@@ -26,7 +26,7 @@ class RandomTreeFactory {
 public:
 	static tree::RankedTree < > generateRankedTree ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, int maxRank = INT_MAX );
 	static tree::RankedPattern < > generateRankedPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, int maxRank = INT_MAX );
-	static tree::RankedNonlinearPattern generateRankedNonlinearPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, bool singleNonlinearVariable, int maxRank = INT_MAX );
+	static tree::RankedNonlinearPattern < > generateRankedNonlinearPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, bool singleNonlinearVariable, int maxRank = INT_MAX );
 	static tree::UnrankedTree < > generateUnrankedTree ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, int maxRank = INT_MAX );
 	static tree::UnrankedPattern < > generateUnrankedPattern ( int depth, int nodesCount, int maxAlphabetSize, bool randomizedAlphabet, int maxRank = INT_MAX );
 
diff --git a/alib2data/src/tree/TreeFeatures.h b/alib2data/src/tree/TreeFeatures.h
index 1adc56ac14..0f8b31f622 100644
--- a/alib2data/src/tree/TreeFeatures.h
+++ b/alib2data/src/tree/TreeFeatures.h
@@ -35,6 +35,7 @@ template < class SymbolType = alphabet::Symbol, class RankType = primitive::Unsi
 class RankedTree;
 template < class SymbolType = alphabet::Symbol, class RankType = primitive::Unsigned >
 class RankedPattern;
+template < class SymbolType = alphabet::Symbol, class RankType = primitive::Unsigned >
 class RankedNonlinearPattern;
 class PrefixRankedTree;
 class PrefixRankedBarTree;
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp
index 475f21bfd0..754a5e0c01 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.cpp
@@ -46,7 +46,7 @@ PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Sym
 PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedPattern < > & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar }, variablesBar, tree.getSubtreeWildcard ( ), { }, tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar, tree.getSubtreeWildcard ( ) }, toPrefixRankedBar ( tree.getContent ( ), tree.getSubtreeWildcard ( ), { }, barBase, variablesBar ) ) {
 }
 
-PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedNonlinearPattern & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar }, variablesBar, tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar, tree.getSubtreeWildcard ( ) } + tree.getNonlinearVariables ( ), toPrefixRankedBar ( tree.getContent ( ), tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), barBase, variablesBar ) ) {
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedNonlinearPattern < > & tree ) : PrefixRankedBarNonlinearPattern ( TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar }, variablesBar, tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ) + TreeAuxiliary::computeBars ( tree.getAlphabet ( ), barBase ) + std::set < std::ranked_symbol < > > { variablesBar, tree.getSubtreeWildcard ( ) } + tree.getNonlinearVariables ( ), toPrefixRankedBar ( tree.getContent ( ), tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), barBase, variablesBar ) ) {
 }
 
 PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const PrefixRankedBarTree & tree ) : PrefixRankedBarNonlinearPattern ( tree.getBars ( ) + std::set < std::ranked_symbol < > > { alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL }, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL, { }, tree.getAlphabet ( ) + std::set < std::ranked_symbol < > > { alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, alphabet::SubtreeWildcardSymbol::RANKED_SUBTREE_WILDCARD_SYMBOL }, tree.getContent ( ) ) {
@@ -61,7 +61,7 @@ PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedT
 PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedPattern < > & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
 }
 
-PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
+PrefixRankedBarNonlinearPattern::PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern < > & tree ) : PrefixRankedBarNonlinearPattern ( alphabet::BarSymbol::BAR_SYMBOL, alphabet::VariablesBarSymbol::RANKED_BAR_SYMBOL, tree ) {
 }
 
 std::vector < std::ranked_symbol < > > PrefixRankedBarNonlinearPattern::toPrefixRankedBar ( const std::tree < std::ranked_symbol < > > & tree, const std::ranked_symbol < > & subtreeWildcard, const std::set < std::ranked_symbol < > > & nonlinearVariables, const alphabet::Symbol & barBase, const std::ranked_symbol < > & variablesBar ) {
@@ -196,7 +196,7 @@ auto prefixRankedBarNonlinearPatternParserRegister3 = xmlApi < alib::Object >::P
 
 auto PrefixRankedBarNonlinearPatternFromRankedTree = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::RankedTree < > > ( );
 auto PrefixRankedBarNonlinearPatternFromRankedPattern = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::RankedPattern < > > ( );
-auto PrefixRankedBarNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::RankedNonlinearPattern > ( );
+auto PrefixRankedBarNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::RankedNonlinearPattern < > > ( );
 auto PrefixRankedBarNonlinearPatternFromPrefixRankedBarTree = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::PrefixRankedBarTree > ( );
 auto PrefixRankedBarNonlinearPatternFromPrefixRankedBarPattern = castApi::CastRegister < ::tree::PrefixRankedBarNonlinearPattern, ::tree::PrefixRankedBarPattern > ( );
 auto PrefixRankedBarNonlinearPatternCastBinder = castApi::CastPoolStringBinder < ::tree::PrefixRankedBarNonlinearPattern > ( ::tree::PrefixRankedBarNonlinearPattern::getXmlTagName ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
index 055b4aee44..61af78b9d0 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarNonlinearPattern.h
@@ -41,12 +41,12 @@ public:
 	explicit PrefixRankedBarNonlinearPattern ( std::set < std::ranked_symbol < > > bar, std::ranked_symbol < > variablesBar, std::ranked_symbol < > subtreeWildcard, std::vector < std::ranked_symbol < > > data );
 	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedTree < > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedPattern < > & tree );
-	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedNonlinearPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( alphabet::Symbol barBase, std::ranked_symbol < > variablesBar, const RankedNonlinearPattern < > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( const PrefixRankedBarTree & tree );
 	explicit PrefixRankedBarNonlinearPattern ( const PrefixRankedBarPattern & tree );
 	explicit PrefixRankedBarNonlinearPattern ( const RankedTree < > & tree );
 	explicit PrefixRankedBarNonlinearPattern ( const RankedPattern < > & tree );
-	explicit PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern & tree );
+	explicit PrefixRankedBarNonlinearPattern ( const RankedNonlinearPattern < > & tree );
 
 	virtual RankedTreeBase * clone ( ) const;
 	virtual RankedTreeBase * plunder ( ) &&;
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
index 00bd1aa036..2616889064 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
@@ -52,7 +52,7 @@ PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedTree <
 PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedPattern < > & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), { }, tree.getAlphabet ( ), toPrefixRanked ( tree.getContent ( ) ) ) {
 }
 
-PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedNonlinearPattern & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ), toPrefixRanked ( tree.getContent ( ) ) ) {
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( const RankedNonlinearPattern < > & tree ) : PrefixRankedNonlinearPattern ( tree.getSubtreeWildcard ( ), tree.getNonlinearVariables ( ), tree.getAlphabet ( ), toPrefixRanked ( tree.getContent ( ) ) ) {
 }
 
 std::vector < std::ranked_symbol < > > PrefixRankedNonlinearPattern::toPrefixRanked ( const std::tree < std::ranked_symbol < > > & tree ) {
@@ -163,7 +163,7 @@ auto prefixRankedNonlinearPatternParserRegister3 = xmlApi < alib::Object >::Pars
 
 auto PrefixRankedNonlinearPatternFromRankedTree = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::RankedTree < > > ( );
 auto PrefixRankedNonlinearPatternFromRankedPattern = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::RankedPattern < > > ( );
-auto PrefixRankedNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::RankedNonlinearPattern > ( );
+auto PrefixRankedNonlinearPatternFromRankedNonlinearPattern = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::RankedNonlinearPattern < > > ( );
 auto PrefixRankedNonlinearPatternFromPrefixRankedTree = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::PrefixRankedTree > ( );
 auto PrefixRankedNonlinearPatternFromPrefixRankedPattern = castApi::CastRegister < ::tree::PrefixRankedNonlinearPattern, ::tree::PrefixRankedPattern > ( );
 auto PrefixRankedNonlinearPatternCastBinder = castApi::CastPoolStringBinder < ::tree::PrefixRankedNonlinearPattern > ( ::tree::PrefixRankedNonlinearPattern::getXmlTagName ( ) );
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index 176644918b..dc338e87f0 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -41,7 +41,7 @@ public:
 	explicit PrefixRankedNonlinearPattern ( const PrefixRankedPattern & tree );
 	explicit PrefixRankedNonlinearPattern ( const RankedTree < > & tree );
 	explicit PrefixRankedNonlinearPattern ( const RankedPattern < > & tree );
-	explicit PrefixRankedNonlinearPattern ( const RankedNonlinearPattern & tree );
+	explicit PrefixRankedNonlinearPattern ( const RankedNonlinearPattern < > & tree );
 
 	virtual RankedTreeBase * clone ( ) const;
 	virtual RankedTreeBase * plunder ( ) &&;
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
index 1eaf762b1a..8295592ef4 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
@@ -6,125 +6,16 @@
  */
 
 #include "RankedNonlinearPattern.h"
-
-#include <iostream>
-#include <algorithm>
-#include <sstream>
-
-#include "../unranked/UnrankedNonlinearPattern.h"
-
-#include <sax/FromXMLParserHelper.h>
-#include "../common/TreeFromXMLParser.h"
-#include "../common/TreeToXMLComposer.h"
-#include "../common/TreeAuxiliary.h"
 #include "../Tree.h"
 #include "../RankedTreeWrapper.h"
 #include <object/Object.h>
 #include <core/xmlApi.hpp>
 #include <core/castApi.hpp>
 
-namespace tree {
-
-RankedNonlinearPattern::RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::set < std::ranked_symbol < > > nonlinearVariables, std::set < std::ranked_symbol < > > alphabet, std::tree < std::ranked_symbol < > > pattern ) : std::Components < RankedNonlinearPattern, std::ranked_symbol < >, 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::RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::set < std::ranked_symbol < > > nonlinearVariables, std::tree < std::ranked_symbol < > > pattern ) : RankedNonlinearPattern ( subtreeWildcard, nonlinearVariables, std::set < std::ranked_symbol < > > ( pattern.prefix_begin ( ), pattern.prefix_end ( ) ) + nonlinearVariables + std::set < std::ranked_symbol < > > { subtreeWildcard }, pattern ) {
-}
-
-RankedNonlinearPattern::RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::tree < std::ranked_symbol < > > pattern ) : RankedNonlinearPattern ( subtreeWildcard, std::set < std::ranked_symbol < > > { }, pattern ) {
-}
-
-RankedNonlinearPattern::RankedNonlinearPattern ( const UnrankedNonlinearPattern < > & other ) : RankedNonlinearPattern ( std::ranked_symbol < > ( other.getSubtreeWildcard ( ), 0 ), TreeAuxiliary::toRankedTree ( other.getContent ( ) ) ) {
-}
-
-RankedTreeBase * RankedNonlinearPattern::clone ( ) const {
-	return new RankedNonlinearPattern ( * this );
-}
-
-RankedTreeBase * RankedNonlinearPattern::plunder ( ) && {
-	return new RankedNonlinearPattern ( std::move ( * this ) );
-}
-
-const std::tree < std::ranked_symbol < > > & RankedNonlinearPattern::getContent ( ) const {
-	return content;
-}
-
-void RankedNonlinearPattern::checkAlphabet ( const std::tree < std::ranked_symbol < > > & data ) const {
-	std::set < std::ranked_symbol < > > minimalAlphabet ( data.prefix_begin ( ), data.prefix_end ( ) );
-	std::set < std::ranked_symbol < > > unknownSymbols;
-	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet().begin ( ), getAlphabet().end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
-
-	if ( unknownSymbols.size ( ) > 0 )
-		throw exception::CommonException ( "Input symbols not in the alphabet." );
-}
-
-void RankedNonlinearPattern::checkArities ( const std::tree < std::ranked_symbol < > > & data ) const {
-	if ( data.getData ( ).getRank ( ).getData ( ) != data.getChildren ( ).size ( ) )
-		throw exception::CommonException ( "Invalid rank." );
-
-	for ( const std::tree < std::ranked_symbol < > > & child : data )
-		checkArities ( child );
-}
-
-void RankedNonlinearPattern::setTree ( std::tree < std::ranked_symbol < > > pattern ) {
-	checkAlphabet ( pattern );
-	checkArities ( pattern );
-
-	this->content = std::move ( pattern );
-}
-
-void RankedNonlinearPattern::operator >>( std::ostream & out ) const {
-	out << "(RankedNonlinearPattern " << this->content << ")";
-}
-
-int RankedNonlinearPattern::compare ( const RankedNonlinearPattern & other ) const {
-	auto first = std::tie ( content, getAlphabet(), getSubtreeWildcard(), getNonlinearVariables() );
-	auto second = std::tie ( other.content, other.getAlphabet(), other.getSubtreeWildcard(), getNonlinearVariables() );
-
-	std::compare < decltype ( first ) > comp;
-
-	return comp ( first, second );
-}
-
-void RankedNonlinearPattern::nicePrint ( std::ostream & os ) const {
-	content.nicePrint ( os );
-}
-
-RankedNonlinearPattern::operator std::string ( ) const {
-	std::stringstream ss;
-	ss << * this;
-	return ss.str ( );
-}
-
-RankedNonlinearPattern RankedNonlinearPattern::parse ( std::deque < sax::Token >::iterator & input ) {
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, RankedNonlinearPattern::getXmlTagName() );
-	std::ranked_symbol < > subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRawRankedSymbol ( input );
-	std::set < std::ranked_symbol < > > nonlinearVariables = TreeFromXMLParser::parseRankedNonlinearVariables ( input );
-	std::set < std::ranked_symbol < > > rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet ( input );
-	std::tree < std::ranked_symbol < > > root = TreeFromXMLParser::parseRankedTreeContent ( input );
-	RankedNonlinearPattern tree ( std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( root ) );
-
-	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, RankedNonlinearPattern::getXmlTagName() );
-	return tree;
-}
-
-void RankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const {
-	out.emplace_back ( RankedNonlinearPattern::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
-	TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard() );
-	TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables() );
-	TreeToXMLComposer::composeAlphabet ( out, getAlphabet() );
-	TreeToXMLComposer::composeContent ( out, getContent ( ) );
-	out.emplace_back ( RankedNonlinearPattern::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
-}
-
-} /* namespace tree */
-
 namespace alib {
 
-auto RankedNonlinearPatternParserRegister  = xmlApi < ::tree::Tree >::ParserRegister < ::tree::RankedNonlinearPattern > ( );
-auto RankedNonlinearPatternParserRegister2 = xmlApi < ::tree::RankedTreeWrapper >::ParserRegister < ::tree::RankedNonlinearPattern > ( );
-auto RankedNonlinearPatternParserRegister3 = xmlApi < alib::Object >::ParserRegister < ::tree::RankedNonlinearPattern > ( );
+auto RankedNonlinearPatternParserRegister = xmlApi < ::tree::Tree >::ParserRegister < ::tree::RankedNonlinearPattern < > > ( );
+auto RankedNonlinearPatternParserRegister2 = xmlApi < ::tree::RankedTreeWrapper >::ParserRegister < ::tree::RankedNonlinearPattern < > > ( );
+auto RankedNonlinearPatternParserRegister3 = xmlApi < alib::Object >::ParserRegister < ::tree::RankedNonlinearPattern < > > ( );
 
 } /* namespace alib */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index 82f79a8492..dcab13259e 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -11,11 +11,19 @@
 #include <string>
 #include <set>
 #include <tree>
+#include <iostream>
+#include <algorithm>
+#include <sstream>
+
 #include <core/components.hpp>
+#include <sax/FromXMLParserHelper.h>
 
 #include "../TreeFeatures.h"
 #include "../TreeException.h"
 #include "../RankedTreeBase.h"
+#include "../common/TreeFromXMLParser.h"
+#include "../common/TreeToXMLComposer.h"
+#include "../common/TreeAuxiliary.h"
 
 namespace tree {
 
@@ -27,55 +35,56 @@ class NonlinearAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class RankedNonlinearPattern : public RankedTreeBase, public std::Components < RankedNonlinearPattern, std::ranked_symbol < >, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
-	std::tree < std::ranked_symbol < > > content;
+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;
 
-	void checkAlphabet ( const std::tree < std::ranked_symbol < > > & pattern ) const;
+	void checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & pattern ) const;
 
-	void checkArities ( const std::tree < std::ranked_symbol < > > & data ) const;
+	void checkArities ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & data ) const;
 
 public:
 	/**
-	 * @copydoc std::tree < std::ranked_symbol < > >::clone() const
+	 * @copydoc std::tree < std::ranked_symbol < SymbolType, RankType > >::clone() const
 	 */
 	virtual RankedTreeBase * clone ( ) const;
 
 	/**
-	 * @copydoc std::tree < std::ranked_symbol < > >::plunder() const
+	 * @copydoc std::tree < std::ranked_symbol < SymbolType, RankType > >::plunder() const
 	 */
 	virtual RankedTreeBase * plunder ( ) &&;
 
-	explicit RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::set < std::ranked_symbol < > > nonlinearVariables, std::set < std::ranked_symbol < > > alphabet, std::tree < std::ranked_symbol < > > pattern );
-	explicit RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::set < std::ranked_symbol < > > nonlinearVariables, std::tree < std::ranked_symbol < > > pattern );
-	explicit RankedNonlinearPattern ( std::ranked_symbol < > subtreeWildcard, std::tree < std::ranked_symbol < > > pattern );
+	explicit 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 );
+	explicit RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern );
+	explicit RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern );
 	explicit RankedNonlinearPattern ( const UnrankedNonlinearPattern < > & other );
 
 	/**
 	 * @return Root node of the regular expression pattern
 	 */
-	const std::tree < std::ranked_symbol < > > & getContent ( ) const;
+	const std::tree < std::ranked_symbol < SymbolType, RankType > > & getContent ( ) const;
 
-	const std::set < std::ranked_symbol < > > & getAlphabet ( ) const {
-		return accessComponent < GeneralAlphabet > ( ).get ( );
+	const std::set < std::ranked_symbol < SymbolType, RankType > > & getAlphabet ( ) const {
+		return this->template accessComponent < GeneralAlphabet > ( ).get ( );
 	}
 
-	void extendAlphabet ( const std::set < std::ranked_symbol < > > & symbols ) {
-		accessComponent < GeneralAlphabet > ( ).add ( symbols );
+	void extendAlphabet ( const std::set < std::ranked_symbol < SymbolType, RankType > > & symbols ) {
+		this->template accessComponent < GeneralAlphabet > ( ).add ( symbols );
 	}
 
-	const std::ranked_symbol < > & getSubtreeWildcard ( ) const {
-		return accessElement < SubtreeWildcard > ( ).get ( );
+	const std::ranked_symbol < SymbolType, RankType > & getSubtreeWildcard ( ) const {
+		return this->template accessElement < SubtreeWildcard > ( ).get ( );
 	}
 
-	const std::set < std::ranked_symbol < > > & getNonlinearVariables ( ) const {
-		return accessComponent < NonlinearAlphabet > ( ).get ( );
+	const std::set < std::ranked_symbol < SymbolType, RankType > > & getNonlinearVariables ( ) const {
+		return this->template accessComponent < NonlinearAlphabet > ( ).get ( );
 	}
 
 	/**
 	 * Sets the root node of the regular expression pattern
 	 * @param pattern root node to set
 	 */
-	void setTree ( std::tree < std::ranked_symbol < > > pattern );
+	void setTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > pattern );
 
 	/**
 	 * Prints XML representation of the pattern to the output stream.
@@ -109,56 +118,172 @@ public:
 
 } /* namespace tree */
 
+#include "../unranked/UnrankedNonlinearPattern.h"
+
+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 );
+}
+
+template < class SymbolType, class RankType >
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : RankedNonlinearPattern ( subtreeWildcard, nonlinearVariables, std::set < std::ranked_symbol < SymbolType, RankType > > ( pattern.prefix_begin ( ), pattern.prefix_end ( ) ) + nonlinearVariables + std::set < std::ranked_symbol < SymbolType, RankType > > { subtreeWildcard }, pattern ) {
+}
+
+template < class SymbolType, class RankType >
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > subtreeWildcard, std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) : RankedNonlinearPattern ( subtreeWildcard, std::set < std::ranked_symbol < SymbolType, RankType > > { }, pattern ) {
+}
+
+template < class SymbolType, class RankType >
+RankedNonlinearPattern < SymbolType, RankType >::RankedNonlinearPattern ( const UnrankedNonlinearPattern < > & other ) : RankedNonlinearPattern ( std::ranked_symbol < SymbolType, RankType > ( other.getSubtreeWildcard ( ), 0 ), TreeAuxiliary::toRankedTree ( other.getContent ( ) ) ) {
+}
+
+template < class SymbolType, class RankType >
+RankedTreeBase * RankedNonlinearPattern < SymbolType, RankType >::clone ( ) const {
+	return new RankedNonlinearPattern ( * this );
+}
+
+template < class SymbolType, class RankType >
+RankedTreeBase * RankedNonlinearPattern < SymbolType, RankType >::plunder ( ) && {
+	return new RankedNonlinearPattern ( std::move ( * this ) );
+}
+
+template < class SymbolType, class RankType >
+const std::tree < std::ranked_symbol < SymbolType, RankType > > & RankedNonlinearPattern < SymbolType, RankType >::getContent ( ) const {
+	return content;
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::checkAlphabet ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & data ) const {
+	std::set < std::ranked_symbol < SymbolType, RankType > > minimalAlphabet ( data.prefix_begin ( ), data.prefix_end ( ) );
+	std::set < std::ranked_symbol < SymbolType, RankType > > unknownSymbols;
+	std::set_difference ( minimalAlphabet.begin ( ), minimalAlphabet.end ( ), getAlphabet().begin ( ), getAlphabet().end ( ), std::inserter ( unknownSymbols, unknownSymbols.end ( ) ) );
+
+	if ( unknownSymbols.size ( ) > 0 )
+		throw exception::CommonException ( "Input symbols not in the alphabet." );
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::checkArities ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & data ) const {
+	if ( data.getData ( ).getRank ( ).getData ( ) != data.getChildren ( ).size ( ) )
+		throw exception::CommonException ( "Invalid rank." );
+
+	for ( const std::tree < std::ranked_symbol < SymbolType, RankType > > & child : data )
+		checkArities ( child );
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::setTree ( std::tree < std::ranked_symbol < SymbolType, RankType > > pattern ) {
+	checkAlphabet ( pattern );
+	checkArities ( pattern );
+
+	this->content = std::move ( pattern );
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::operator >>( std::ostream & out ) const {
+	out << "(RankedNonlinearPattern " << this->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() );
+
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::nicePrint ( std::ostream & os ) const {
+	content.nicePrint ( os );
+}
+
+template < class SymbolType, class RankType >
+RankedNonlinearPattern < SymbolType, RankType >::operator std::string ( ) const {
+	std::stringstream ss;
+	ss << * this;
+	return ss.str ( );
+}
+
+template < class SymbolType, class RankType >
+RankedNonlinearPattern < SymbolType, RankType > RankedNonlinearPattern < SymbolType, RankType >::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, RankedNonlinearPattern::getXmlTagName() );
+	std::ranked_symbol < SymbolType, RankType > subtreeWildcardSymbol = TreeFromXMLParser::parseSubtreeWildcardRawRankedSymbol ( input );
+	std::set < std::ranked_symbol < SymbolType, RankType > > nonlinearVariables = TreeFromXMLParser::parseRankedNonlinearVariables ( input );
+	std::set < std::ranked_symbol < SymbolType, RankType > > rankedAlphabet = TreeFromXMLParser::parseRankedAlphabet ( input );
+	std::tree < std::ranked_symbol < SymbolType, RankType > > root = TreeFromXMLParser::parseRankedTreeContent ( input );
+	RankedNonlinearPattern < SymbolType, RankType > tree ( std::move ( subtreeWildcardSymbol ), std::move ( nonlinearVariables ), std::move ( rankedAlphabet ), std::move ( root ) );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, RankedNonlinearPattern::getXmlTagName() );
+	return tree;
+}
+
+template < class SymbolType, class RankType >
+void RankedNonlinearPattern < SymbolType, RankType >::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( RankedNonlinearPattern::getXmlTagName(), sax::Token::TokenType::START_ELEMENT );
+	TreeToXMLComposer::composeSubtreeWildcard ( out, getSubtreeWildcard() );
+	TreeToXMLComposer::composeNonlinearVariables ( out, getNonlinearVariables() );
+	TreeToXMLComposer::composeAlphabet ( out, getAlphabet() );
+	TreeToXMLComposer::composeContent ( out, getContent ( ) );
+	out.emplace_back ( RankedNonlinearPattern::getXmlTagName(), sax::Token::TokenType::END_ELEMENT );
+}
+
+} /* namespace tree */
+
 namespace std {
 
-template < >
-class ComponentConstraint< ::tree::RankedNonlinearPattern, std::ranked_symbol < >, ::tree::GeneralAlphabet > {
+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 & pattern, const std::ranked_symbol < > & symbol ) {
-		const std::tree < std::ranked_symbol < > > & content = pattern.getContent ( );
-		return std::find(content.prefix_begin(), content.prefix_end(), symbol) != content.prefix_end() || pattern.accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+	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 );
 	}
 
-	static bool available ( const ::tree::RankedNonlinearPattern &, const std::ranked_symbol < > & ) {
+	static bool available ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
 		return true;
 	}
 
-	static void valid ( const ::tree::RankedNonlinearPattern &, const std::ranked_symbol < > & ) {
+	static void valid ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
 	}
 };
 
-template < >
-class ComponentConstraint< ::tree::RankedNonlinearPattern, std::ranked_symbol < >, ::tree::NonlinearAlphabet > {
+template < class SymbolType, class RankType >
+class ComponentConstraint< ::tree::RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::NonlinearAlphabet > {
 public:
-	static bool used ( const ::tree::RankedNonlinearPattern &, const std::ranked_symbol < > & ) {
+	static bool used ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > &, const std::ranked_symbol < SymbolType, RankType > & ) {
 		return false;
 	}
 
-	static bool available ( const ::tree::RankedNonlinearPattern & pattern, const std::ranked_symbol < > & symbol ) {
-		return pattern.accessComponent < ::tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	static bool available ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
+		return pattern.template accessComponent < ::tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
 }
 
-	static void valid ( const ::tree::RankedNonlinearPattern & pattern, const std::ranked_symbol < > & symbol) {
+	static void valid ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol) {
 		if( symbol.getRank().getData() != 0 )
 			throw ::tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
 
-		if ( pattern.accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol )
+		if ( pattern.template accessElement < ::tree::SubtreeWildcard > ( ).get ( ) == symbol )
 			throw ::tree::TreeException ( "Symbol " + std::to_string ( symbol ) + "cannot be set as nonlinear variable since it is already subtree wildcard" );
 	}
 };
 
-template < >
-class ElementConstraint< ::tree::RankedNonlinearPattern, std::ranked_symbol < >, ::tree::SubtreeWildcard > {
+template < class SymbolType, class RankType >
+class ElementConstraint< ::tree::RankedNonlinearPattern < SymbolType, RankType >, std::ranked_symbol < SymbolType, RankType >, ::tree::SubtreeWildcard > {
 public:
-	static bool available ( const ::tree::RankedNonlinearPattern & pattern, const std::ranked_symbol < > & symbol ) {
-		return pattern.accessComponent < ::tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	static bool available ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol ) {
+		return pattern.template accessComponent < ::tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
 	}
 
-	static void valid ( const ::tree::RankedNonlinearPattern & pattern, const std::ranked_symbol < > & symbol) {
+	static void valid ( const ::tree::RankedNonlinearPattern < SymbolType, RankType > & pattern, const std::ranked_symbol < SymbolType, RankType > & symbol) {
 		if( symbol.getRank().getData() != 0 )
 			throw ::tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
 
-		if ( pattern.accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+		if ( pattern.template accessComponent < ::tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
 			throw ::tree::TreeException ( "Symbol " + std::to_string ( symbol ) + "cannot be set as subtree wildcard since it is already nonlinear variable" );
 	}
 };
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index 3db9e53262..b72b1a23e8 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -55,7 +55,7 @@ public:
 	explicit UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::set < SymbolType > alphabet, std::tree < SymbolType > pattern );
 	explicit UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::set < SymbolType > nonlinearVariables, std::tree < SymbolType > pattern );
 	explicit UnrankedNonlinearPattern ( SymbolType subtreeWildcard, std::tree < SymbolType > pattern );
-	explicit UnrankedNonlinearPattern ( const RankedNonlinearPattern & other );
+	explicit UnrankedNonlinearPattern ( const RankedNonlinearPattern < > & other );
 
 	/**
 	 * @return Content of the pattern
@@ -140,7 +140,7 @@ UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( SymbolType s
 }
 
 template < class SymbolType >
-UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( const RankedNonlinearPattern & other ) : UnrankedNonlinearPattern ( other.getSubtreeWildcard ( ).getSymbol ( ), TreeAuxiliary::unrankSymbols ( other.getAlphabet ( ) ), TreeAuxiliary::toUnrankedTree ( other.getContent ( ) ) ) {
+UnrankedNonlinearPattern < SymbolType >::UnrankedNonlinearPattern ( const RankedNonlinearPattern < > & other ) : UnrankedNonlinearPattern ( other.getSubtreeWildcard ( ).getSymbol ( ), TreeAuxiliary::unrankSymbols ( other.getAlphabet ( ) ), TreeAuxiliary::toUnrankedTree ( other.getContent ( ) ) ) {
 }
 
 template < class SymbolType >
diff --git a/alib2str/src/tree/TreeFromStringParser.cpp b/alib2str/src/tree/TreeFromStringParser.cpp
index d76ac2b23f..a2202caefb 100644
--- a/alib2str/src/tree/TreeFromStringParser.cpp
+++ b/alib2str/src/tree/TreeFromStringParser.cpp
@@ -42,7 +42,7 @@ Tree TreeFromStringParser::parseTree ( std::istream & input, const std::set < FE
 		} else {
 			std::ranked_symbol < > subtreeWildcard ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), 0 );
 			std::ranked_symbol < > nonlinearVariable ( alphabet::Symbol ( alphabet::NonlinearVariableSymbol ( alphabet::symbolFrom ( token.value ) ) ), 0 );
-			return Tree ( RankedNonlinearPattern ( subtreeWildcard, { nonlinearVariable }, std::tree < std::ranked_symbol < > > ( nonlinearVariable, { } ) ) );
+			return Tree ( RankedNonlinearPattern < > ( subtreeWildcard, { nonlinearVariable }, std::tree < std::ranked_symbol < > > ( nonlinearVariable, { } ) ) );
 		}
 	} else {
 		m_TreeLexer.putback ( input, token );
@@ -65,7 +65,7 @@ Tree TreeFromStringParser::parseTree ( std::istream & input, const std::set < FE
 
 			if ( isPattern && nonlinearVariables.size ( ) ) {
 				std::ranked_symbol < > subtreeWildcard ( alphabet::Symbol ( alphabet::SubtreeWildcardSymbol::SUBTREE_WILDCARD ), 0 );
-				RankedNonlinearPattern tree ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ), std::tree < std::ranked_symbol < > > ( std::ranked_symbol < > ( std::move ( symbol ), rank ), std::move ( childs ) ) );
+				RankedNonlinearPattern < > tree ( std::move ( subtreeWildcard ), std::move ( nonlinearVariables ), std::tree < std::ranked_symbol < > > ( std::ranked_symbol < > ( std::move ( symbol ), rank ), std::move ( childs ) ) );
 
 				if ( features.count ( FEATURES::RANKED_NONLINEAR_PATTERN ) ) return Tree ( std::move ( tree ) );
 			} else if ( isPattern ) {
diff --git a/arand2/src/arand.cpp b/arand2/src/arand.cpp
index 273a1ea6a1..d245927b86 100644
--- a/arand2/src/arand.cpp
+++ b/arand2/src/arand.cpp
@@ -193,7 +193,7 @@ int main ( int argc, char * argv[] ) {
 		} else if ( type.getValue ( ) == "RNP" ) {
 			measurements::start ( "Algorithm", measurements::Type::MAIN );
 
-			tree::RankedNonlinearPattern res = tree::generate::RandomTreeFactory::generateRankedNonlinearPattern ( height.getValue ( ), nodes.getValue ( ), alphabetSize.getValue ( ), randomizedAlphabet.getValue ( ), singleNonlinearVariable.getValue ( ), maxRank.getValue ( ) );
+			tree::RankedNonlinearPattern < > res = tree::generate::RandomTreeFactory::generateRankedNonlinearPattern ( height.getValue ( ), nodes.getValue ( ), alphabetSize.getValue ( ), randomizedAlphabet.getValue ( ), singleNonlinearVariable.getValue ( ), maxRank.getValue ( ) );
 
 			measurements::end ( );
 			measurements::start ( "Output write", measurements::Type::AUXILIARY );
-- 
GitLab