From 1d69561938626008c821f5da49fe22d22f99c057 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Tue, 2 Aug 2016 15:01:29 +0200
Subject: [PATCH] update tree structures to components2

---
 .../src/tree/ranked/PrefixRankedBarPattern.h  |  2 +-
 .../src/tree/ranked/PrefixRankedBarTree.cpp   | 41 +----------
 .../src/tree/ranked/PrefixRankedBarTree.h     | 43 +++++++++++-
 .../ranked/PrefixRankedNonlinearPattern.cpp   | 65 +-----------------
 .../ranked/PrefixRankedNonlinearPattern.h     | 62 ++++++++++++++++-
 .../src/tree/ranked/PrefixRankedPattern.cpp   | 36 +---------
 .../src/tree/ranked/PrefixRankedPattern.h     | 39 ++++++++++-
 .../src/tree/ranked/PrefixRankedTree.cpp      | 23 +------
 alib2data/src/tree/ranked/PrefixRankedTree.h  | 26 ++++++-
 .../tree/ranked/RankedNonlinearPattern.cpp    | 68 +------------------
 .../src/tree/ranked/RankedNonlinearPattern.h  | 60 +++++++++++++++-
 alib2data/src/tree/ranked/RankedPattern.cpp   | 38 +----------
 alib2data/src/tree/ranked/RankedPattern.h     | 37 +++++++++-
 alib2data/src/tree/ranked/RankedTree.cpp      | 25 +------
 alib2data/src/tree/ranked/RankedTree.h        | 24 ++++++-
 alib2data/src/tree/unranked/PrefixBarTree.cpp | 31 +--------
 alib2data/src/tree/unranked/PrefixBarTree.h   | 36 +++++++++-
 .../unranked/UnrankedNonlinearPattern.cpp     | 62 +----------------
 .../tree/unranked/UnrankedNonlinearPattern.h  | 54 ++++++++++++++-
 .../src/tree/unranked/UnrankedPattern.cpp     | 36 +---------
 alib2data/src/tree/unranked/UnrankedPattern.h | 35 +++++++++-
 alib2data/src/tree/unranked/UnrankedTree.cpp  | 25 +------
 alib2data/src/tree/unranked/UnrankedTree.h    | 24 ++++++-
 23 files changed, 442 insertions(+), 450 deletions(-)

diff --git a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
index cb4d4f907b..c716d8efa3 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarPattern.h
@@ -111,7 +111,7 @@ template < >
 class ComponentConstraint2< tree::PrefixRankedBarPattern, alphabet::RankedSymbol, tree::GeneralAlphabet > {
 public:
 	static bool used ( const tree::PrefixRankedBarPattern & pattern, const alphabet::RankedSymbol & symbol ) {
-	const std::vector < alphabet::RankedSymbol > & content = pattern.getContent ( );
+		const std::vector < alphabet::RankedSymbol > & content = pattern.getContent ( );
 
 		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern.accessElement < tree::VariablesBarSymbol > ( ).get ( ) == symbol || pattern.accessComponent < tree::BarSymbols > ( ).get ( ).count ( symbol ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
 	}
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
index f430304b38..21e311ee85 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "PrefixRankedBarTree.h"
-#include "../TreeException.h"
 
 #include <sstream>
 #include <algorithm>
@@ -28,7 +27,7 @@
 
 namespace tree {
 
-PrefixRankedBarTree::PrefixRankedBarTree ( std::set < alphabet::RankedSymbol > bars, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedBarTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::tuple < > ( ) ) {
+PrefixRankedBarTree::PrefixRankedBarTree ( std::set < alphabet::RankedSymbol > bars, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components2 < PrefixRankedBarTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ), std::move ( bars ) ), std::tuple < > ( ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -154,44 +153,6 @@ void PrefixRankedBarTree::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const std::vector < alphabet::RankedSymbol > & content = static_cast < const tree::PrefixRankedBarTree * > ( this )->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
-}
-
-template < >
-bool tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-template < >
-bool tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::BarSymbols >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const std::vector < alphabet::RankedSymbol > & content = static_cast < const tree::PrefixRankedBarTree * > ( this )->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
-}
-
-template < >
-bool tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::BarSymbols >::available ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedBarTree * tree = static_cast < const tree::PrefixRankedBarTree * > ( this );
-
-	return tree->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::PrefixRankedBarTree::Component < tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::BarSymbols >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto prefixRankedBarTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedBarTree > ();
diff --git a/alib2data/src/tree/ranked/PrefixRankedBarTree.h b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
index e098af96a0..e51e867b68 100644
--- a/alib2data/src/tree/ranked/PrefixRankedBarTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedBarTree.h
@@ -10,8 +10,9 @@
 
 #include <set>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "../RankedTreeBase.h"
 #include "RankedNode.h"
@@ -26,7 +27,7 @@ class BarSymbols;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedBarTree : public RankedTreeBase, public std::Components < PrefixRankedBarTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > {
+class PrefixRankedBarTree : public RankedTreeBase, public std::Components2 < PrefixRankedBarTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, BarSymbols >, std::tuple < > > {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	static void toPrefixRankedBar ( const RankedNode & node, const alphabet::Symbol & barBase, std::vector < alphabet::RankedSymbol > & linearNotation );
@@ -92,4 +93,42 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::PrefixRankedBarTree & tree, const alphabet::RankedSymbol & symbol ) {
+		const std::vector < alphabet::RankedSymbol > & content = tree.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
+	}
+
+	static bool available ( const tree::PrefixRankedBarTree &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::PrefixRankedBarTree &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedBarTree, alphabet::RankedSymbol, tree::BarSymbols > {
+public:
+	static bool used ( const tree::PrefixRankedBarTree & tree, const alphabet::RankedSymbol & symbol ) {
+		const std::vector < alphabet::RankedSymbol > & content = tree.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
+	}
+
+	static bool available ( const tree::PrefixRankedBarTree & tree, const alphabet::RankedSymbol & symbol ) {
+		return tree.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::PrefixRankedBarTree &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* PREFIX_RANKED_BAR_TREE_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
index 46152b78a7..a3eda5ef29 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "PrefixRankedNonlinearPattern.h"
-#include "../TreeException.h"
 
 #include <sstream>
 #include <algorithm>
@@ -31,7 +30,7 @@
 
 namespace tree {
 
-PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( subtreeWildcard ) ) {
+PrefixRankedNonlinearPattern::PrefixRankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components2 < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( subtreeWildcard ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -170,68 +169,6 @@ void PrefixRankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) c
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
-	const std::vector < alphabet::RankedSymbol > & content = pattern->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
-}
-
-template < >
-bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-template < >
-bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::used ( const alphabet::RankedSymbol & ) const {
-	return false;
-}
-
-template < >
-bool tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::available ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::PrefixRankedNonlinearPattern::Component < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
-
-	if ( symbol.getRank ( ).getData ( ) != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-
-	if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
-}
-
-template < >
-bool tree::PrefixRankedNonlinearPattern::Element < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::PrefixRankedNonlinearPattern::Element < tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedNonlinearPattern * pattern = static_cast < const tree::PrefixRankedNonlinearPattern * > ( this );
-
-	if ( symbol.getRank ( ).getData ( ) != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-
-	if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto prefixRankedNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedNonlinearPattern > ( );
diff --git a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
index f65e264799..915e334c73 100644
--- a/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedNonlinearPattern.h
@@ -10,8 +10,9 @@
 
 #include <set>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "../RankedTreeBase.h"
 #include "RankedNode.h"
@@ -32,7 +33,7 @@ class NonlinearAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedNonlinearPattern : public RankedTreeBase, public std::Components < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class PrefixRankedNonlinearPattern : public RankedTreeBase, public std::Components2 < PrefixRankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	static std::vector < alphabet::RankedSymbol > toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard, const std::set < alphabet::RankedSymbol > & nonlinearVariables );
@@ -106,4 +107,61 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::PrefixRankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		const std::vector < alphabet::RankedSymbol > & content = pattern.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+	}
+
+	static bool available ( const tree::PrefixRankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::PrefixRankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet > {
+public:
+	static bool used ( const tree::PrefixRankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+		return false;
+	}
+
+	static bool available ( const tree::PrefixRankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::PrefixRankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol) {
+		if ( symbol.getRank ( ).getData ( ) != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+		if ( pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+	}
+};
+
+template < >
+class ElementConstraint2< tree::PrefixRankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::PrefixRankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::PrefixRankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol) {
+		if ( symbol.getRank ( ).getData ( ) != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+		if ( pattern.accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+	}
+};
+
+} /* namespace std */
+
 #endif /* PREFIX_RANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
index fad5af6a8d..c5efa441ae 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "PrefixRankedPattern.h"
-#include "../TreeException.h"
 
 #include <sstream>
 #include <algorithm>
@@ -28,7 +27,7 @@
 
 namespace tree {
 
-PrefixRankedPattern::PrefixRankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( subtreeWildcard ) ) {
+PrefixRankedPattern::PrefixRankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components2 < PrefixRankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( subtreeWildcard ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -147,39 +146,6 @@ void PrefixRankedPattern::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::PrefixRankedPattern::Component < tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::PrefixRankedPattern * pattern = static_cast < const tree::PrefixRankedPattern * > ( this );
-	const std::vector < alphabet::RankedSymbol > & content = pattern->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
-}
-
-template < >
-bool tree::PrefixRankedPattern::Component < tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::PrefixRankedPattern::Component < tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-template < >
-bool tree::PrefixRankedPattern::Element < tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
-	return static_cast < const tree::PrefixRankedPattern * > ( this )->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::PrefixRankedPattern::Element < tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	if( symbol.getRank().getData() != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-}
-
-} /* namespace std */
-
-
 namespace alib {
 
 auto prefixRankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedPattern > ();
diff --git a/alib2data/src/tree/ranked/PrefixRankedPattern.h b/alib2data/src/tree/ranked/PrefixRankedPattern.h
index 8f9c185889..873c625f14 100644
--- a/alib2data/src/tree/ranked/PrefixRankedPattern.h
+++ b/alib2data/src/tree/ranked/PrefixRankedPattern.h
@@ -10,8 +10,9 @@
 
 #include <set>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "../RankedTreeBase.h"
 #include "RankedNode.h"
@@ -27,7 +28,7 @@ class SubtreeWildcard;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedPattern : public RankedTreeBase, public std::Components < PrefixRankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class PrefixRankedPattern : public RankedTreeBase, public std::Components2 < PrefixRankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	static std::vector < alphabet::RankedSymbol > toPrefixRanked ( const RankedNode & node, const alphabet::RankedSymbol & subtreeWildcard );
@@ -93,4 +94,38 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::PrefixRankedPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		const std::vector < alphabet::RankedSymbol > & content = pattern.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+	}
+
+	static bool available ( const tree::PrefixRankedPattern &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::PrefixRankedPattern &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+template < >
+class ElementConstraint2< tree::PrefixRankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::PrefixRankedPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::PrefixRankedPattern &, const alphabet::RankedSymbol & symbol) {
+		if( symbol.getRank().getData() != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+	}
+};
+
+} /* namespace std */
+
 #endif /* PREFIX_RANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.cpp b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
index 9ce420f232..5a4f270abc 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.cpp
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "PrefixRankedTree.h"
-#include "../TreeException.h"
 
 #include <sstream>
 #include <algorithm>
@@ -25,7 +24,7 @@
 
 namespace tree {
 
-PrefixRankedTree::PrefixRankedTree ( std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components < PrefixRankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
+PrefixRankedTree::PrefixRankedTree ( std::set < alphabet::RankedSymbol > alphabet, std::vector < alphabet::RankedSymbol > data ) : std::Components2 < PrefixRankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -135,26 +134,6 @@ void PrefixRankedTree::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::PrefixRankedTree::Component < tree::PrefixRankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const std::vector < alphabet::RankedSymbol > & content = static_cast < const tree::PrefixRankedTree * > ( this )->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
-}
-
-template < >
-bool tree::PrefixRankedTree::Component < tree::PrefixRankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::PrefixRankedTree::Component < tree::PrefixRankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto prefixRankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixRankedTree > ();
diff --git a/alib2data/src/tree/ranked/PrefixRankedTree.h b/alib2data/src/tree/ranked/PrefixRankedTree.h
index 52e8a829a3..2d7ffec159 100644
--- a/alib2data/src/tree/ranked/PrefixRankedTree.h
+++ b/alib2data/src/tree/ranked/PrefixRankedTree.h
@@ -10,8 +10,9 @@
 
 #include <set>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "../../alphabet/RankedSymbol.h"
 #include "../RankedTreeBase.h"
 #include "RankedNode.h"
@@ -25,7 +26,7 @@ class GeneralAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixRankedTree : public RankedTreeBase, public std::Components < PrefixRankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class PrefixRankedTree : public RankedTreeBase, public std::Components2 < PrefixRankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::vector < alphabet::RankedSymbol > m_Data;
 
 	static std::vector < alphabet::RankedSymbol > toPrefixRanked ( const RankedNode & node );
@@ -86,4 +87,25 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::PrefixRankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::PrefixRankedTree & tree, const alphabet::RankedSymbol & symbol ) {
+		const std::vector < alphabet::RankedSymbol > & content = tree.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
+	}
+
+	static bool available ( const tree::PrefixRankedTree &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::PrefixRankedTree &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* PREFIX_RANKED_TREE_H_ */
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
index c5c344b5f1..11dd146d2f 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "RankedNonlinearPattern.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -25,7 +24,7 @@
 
 namespace tree {
 
-RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
+RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > nonlinearVariables, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components2 < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
 	setTree ( std::move ( pattern ) );
 }
 
@@ -35,11 +34,11 @@ RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeW
 RankedNonlinearPattern::RankedNonlinearPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNode pattern ) : RankedNonlinearPattern ( subtreeWildcard, std::set < alphabet::RankedSymbol > { }, pattern ) {
 }
 
-RankedNonlinearPattern::RankedNonlinearPattern ( const RankedNonlinearPattern & other ) : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
+RankedNonlinearPattern::RankedNonlinearPattern ( const RankedNonlinearPattern & other ) : std::Components2 < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 }
 
-RankedNonlinearPattern::RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept : std::Components < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ), std::move ( other.accessComponent < NonlinearAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
+RankedNonlinearPattern::RankedNonlinearPattern ( RankedNonlinearPattern && other ) noexcept : std::Components2 < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ), std::move ( other.accessComponent < NonlinearAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 }
 
@@ -133,67 +132,6 @@ void RankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
-
-	return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-template < >
-bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::used ( const alphabet::RankedSymbol & ) const {
-	return false;
-}
-
-template < >
-bool tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::available ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::RankedNonlinearPattern::Component < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
-
-	if( symbol.getRank().getData() != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-
-	if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
-}
-
-template < >
-bool tree::RankedNonlinearPattern::Element < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::RankedNonlinearPattern::Element < tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedNonlinearPattern * pattern = static_cast < const tree::RankedNonlinearPattern * > ( this );
-
-	if( symbol.getRank().getData() != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-
-	if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto RankedNonlinearPatternParserRegister  = xmlApi < tree::Tree >::ParserRegister < tree::RankedNonlinearPattern > ( );
diff --git a/alib2data/src/tree/ranked/RankedNonlinearPattern.h b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
index f52d02ce10..25a72b4c9e 100644
--- a/alib2data/src/tree/ranked/RankedNonlinearPattern.h
+++ b/alib2data/src/tree/ranked/RankedNonlinearPattern.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "RankedNode.h"
 #include "../RankedTreeBase.h"
 
@@ -27,7 +28,7 @@ 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, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class RankedNonlinearPattern : public RankedTreeBase, public std::Components2 < RankedNonlinearPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::smart_ptr < RankedNode > pattern;
 
 public:
@@ -119,4 +120,59 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::RankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.getRoot ( ).testSymbol ( symbol ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static bool available ( const tree::RankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::RankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+template < >
+class ComponentConstraint2< tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::NonlinearAlphabet > {
+public:
+	static bool used ( const tree::RankedNonlinearPattern &, const alphabet::RankedSymbol & ) {
+		return false;
+	}
+
+	static bool available ( const tree::RankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+}
+
+	static void valid ( const tree::RankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol) {
+		if( symbol.getRank().getData() != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+		if ( pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+	}
+};
+
+template < >
+class ElementConstraint2< tree::RankedNonlinearPattern, alphabet::RankedSymbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::RankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::RankedNonlinearPattern & pattern, const alphabet::RankedSymbol & symbol) {
+		if( symbol.getRank().getData() != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+
+		if ( pattern.accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+	}
+};
+
+} /* namespace std */
+
 #endif /* RANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/RankedPattern.cpp b/alib2data/src/tree/ranked/RankedPattern.cpp
index 4f6548c76f..8f7e1f2c5e 100644
--- a/alib2data/src/tree/ranked/RankedPattern.cpp
+++ b/alib2data/src/tree/ranked/RankedPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "RankedPattern.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -25,7 +24,7 @@
 
 namespace tree {
 
-RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
+RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, std::set < alphabet::RankedSymbol > alphabet, RankedNode pattern ) : std::Components2 < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
 	setTree ( std::move ( pattern ) );
 }
 
@@ -35,11 +34,11 @@ RankedPattern::RankedPattern ( alphabet::RankedSymbol subtreeWildcard, RankedNod
 RankedPattern::RankedPattern ( const UnrankedPattern & other ) : RankedPattern ( alphabet::RankedSymbol ( other.getSubtreeWildcard ( ), 0 ), other.getRoot ( ).asRanked ( ) ) {
 }
 
-RankedPattern::RankedPattern ( const RankedPattern & other ) : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
+RankedPattern::RankedPattern ( const RankedPattern & other ) : std::Components2 < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 }
 
-RankedPattern::RankedPattern ( RankedPattern && other ) noexcept : std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
+RankedPattern::RankedPattern ( RankedPattern && other ) noexcept : std::Components2 < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet() ) );
 }
 
@@ -130,37 +129,6 @@ void RankedPattern::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	const tree::RankedPattern * pattern = static_cast < const tree::RankedPattern * > ( this );
-
-	return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
-}
-
-template < >
-bool tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::RankedPattern::Component < tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-template < >
-bool tree::RankedPattern::Element < tree::RankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::available ( const alphabet::RankedSymbol & symbol ) const {
-	return static_cast < const tree::RankedPattern * > ( this )->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::RankedPattern::Element < tree::RankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard >::valid ( const alphabet::RankedSymbol & symbol ) const {
-	if( symbol.getRank().getData() != 0 )
-		throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto rankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedPattern > ();
diff --git a/alib2data/src/tree/ranked/RankedPattern.h b/alib2data/src/tree/ranked/RankedPattern.h
index edcfa94ba6..d0fa2fedea 100644
--- a/alib2data/src/tree/ranked/RankedPattern.h
+++ b/alib2data/src/tree/ranked/RankedPattern.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "RankedNode.h"
 #include "../RankedTreeBase.h"
 
@@ -26,7 +27,7 @@ class SubtreeWildcard;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class RankedPattern : public RankedTreeBase, public std::Components < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class RankedPattern : public RankedTreeBase, public std::Components2 < RankedPattern, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::smart_ptr < RankedNode > pattern;
 
 public:
@@ -114,4 +115,36 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::RankedPattern, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::RankedPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.getRoot ( ).testSymbol ( symbol ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+	}
+
+	static bool available ( const tree::RankedPattern &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::RankedPattern &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+template < >
+class ElementConstraint2< tree::RankedPattern, alphabet::RankedSymbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::RankedPattern & pattern, const alphabet::RankedSymbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::RankedPattern &, const alphabet::RankedSymbol & symbol) {
+		if( symbol.getRank().getData() != 0 )
+			throw tree::TreeException ( "SubtreeWildcard symbol has nonzero arity" );
+	}
+};
+
+} /* namespace std */
+
 #endif /* RANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/ranked/RankedTree.cpp b/alib2data/src/tree/ranked/RankedTree.cpp
index 3f3dcf9d90..0c42ca5e7d 100644
--- a/alib2data/src/tree/ranked/RankedTree.cpp
+++ b/alib2data/src/tree/ranked/RankedTree.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "RankedTree.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -25,7 +24,7 @@
 
 namespace tree {
 
-RankedTree::RankedTree ( std::set < alphabet::RankedSymbol > alphabet, RankedNode tree ) : std::Components < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( nullptr ) {
+RankedTree::RankedTree ( std::set < alphabet::RankedSymbol > alphabet, RankedNode tree ) : std::Components2 < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( nullptr ) {
 	setTree ( std::move ( tree ) );
 }
 
@@ -35,11 +34,11 @@ RankedTree::RankedTree ( RankedNode tree ) : RankedTree ( tree.computeMinimalAlp
 RankedTree::RankedTree ( const UnrankedTree & other ) : RankedTree ( other.getRoot ( ).asRanked ( ) ) {
 }
 
-RankedTree::RankedTree ( const RankedTree & other ) : std::Components < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree ) {
+RankedTree::RankedTree ( const RankedTree & other ) : std::Components2 < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree ) {
 	this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
-RankedTree::RankedTree ( RankedTree && other ) noexcept : std::Components < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( std::move ( other.tree ) ) {
+RankedTree::RankedTree ( RankedTree && other ) noexcept : std::Components2 < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( std::move ( other.tree ) ) {
 	this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
@@ -127,24 +126,6 @@ void RankedTree::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::RankedTree::Component < tree::RankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::used ( const alphabet::RankedSymbol & symbol ) const {
-	return static_cast < const tree::RankedTree * > ( this )->getRoot ( ).testSymbol ( symbol );
-}
-
-template < >
-bool tree::RankedTree::Component < tree::RankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::available ( const alphabet::RankedSymbol & ) const {
-	return true;
-}
-
-template < >
-void tree::RankedTree::Component < tree::RankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet >::valid ( const alphabet::RankedSymbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto rankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::RankedTree > ();
diff --git a/alib2data/src/tree/ranked/RankedTree.h b/alib2data/src/tree/ranked/RankedTree.h
index 6b3b0f0f59..5c7eec37d5 100644
--- a/alib2data/src/tree/ranked/RankedTree.h
+++ b/alib2data/src/tree/ranked/RankedTree.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "RankedNode.h"
 #include "../RankedTreeBase.h"
 
@@ -25,7 +26,7 @@ class GeneralAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of RegExpElement.
  */
-class RankedTree : public RankedTreeBase, public std::Components < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class RankedTree : public RankedTreeBase, public std::Components2 < RankedTree, alphabet::RankedSymbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::smart_ptr < RankedNode > tree;
 
 public:
@@ -109,4 +110,23 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::RankedTree, alphabet::RankedSymbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::RankedTree & tree, const alphabet::RankedSymbol & symbol ) {
+		return tree.getRoot ( ).testSymbol ( symbol );
+	}
+
+	static bool available ( const tree::RankedTree &, const alphabet::RankedSymbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::RankedTree &, const alphabet::RankedSymbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* RANKED_TREE_H_ */
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.cpp b/alib2data/src/tree/unranked/PrefixBarTree.cpp
index cdd2578b15..20894294ad 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.cpp
+++ b/alib2data/src/tree/unranked/PrefixBarTree.cpp
@@ -27,7 +27,7 @@
 
 namespace tree {
 
-PrefixBarTree::PrefixBarTree ( alphabet::Symbol bar, std::set < alphabet::Symbol > alphabet, std::vector < alphabet::Symbol > data ) : std::Components < PrefixBarTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( bar ) ) ) {
+PrefixBarTree::PrefixBarTree ( alphabet::Symbol bar, std::set < alphabet::Symbol > alphabet, std::vector < alphabet::Symbol > data ) : std::Components2 < PrefixBarTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( bar ) ) ) {
 	setContent ( std::move ( data ) );
 }
 
@@ -146,35 +146,6 @@ void PrefixBarTree::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::PrefixBarTree::Component < tree::PrefixBarTree, alphabet::Symbol, tree::GeneralAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const std::vector < alphabet::Symbol > & content = static_cast < const tree::PrefixBarTree * > ( this )->getContent ( );
-
-	return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
-}
-
-template < >
-bool tree::PrefixBarTree::Component < tree::PrefixBarTree, alphabet::Symbol, tree::GeneralAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void tree::PrefixBarTree::Component < tree::PrefixBarTree, alphabet::Symbol, tree::GeneralAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool tree::PrefixBarTree::Element < tree::PrefixBarTree, alphabet::Symbol, tree::BarSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	return static_cast < const tree::PrefixBarTree * > ( this )->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::PrefixBarTree::Element < tree::PrefixBarTree, alphabet::Symbol, tree::BarSymbol >::valid ( const alphabet::Symbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto prefixBarTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::PrefixBarTree > ( );
diff --git a/alib2data/src/tree/unranked/PrefixBarTree.h b/alib2data/src/tree/unranked/PrefixBarTree.h
index 4d696fd774..2edf0e3f01 100644
--- a/alib2data/src/tree/unranked/PrefixBarTree.h
+++ b/alib2data/src/tree/unranked/PrefixBarTree.h
@@ -10,7 +10,7 @@
 
 #include <set>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
 #include "../../alphabet/Symbol.h"
 #include "../UnrankedTreeBase.h"
@@ -26,7 +26,7 @@ class BarSymbol;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of LinearStringElement.
  */
-class PrefixBarTree : public UnrankedTreeBase, public std::Components < PrefixBarTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > {
+class PrefixBarTree : public UnrankedTreeBase, public std::Components2 < PrefixBarTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < BarSymbol > > {
 	std::vector < alphabet::Symbol > m_Data;
 
 	static std::vector < alphabet::Symbol > toPrefixBar ( const UnrankedNode & node, const alphabet::Symbol & bar );
@@ -92,4 +92,36 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::PrefixBarTree, alphabet::Symbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::PrefixBarTree & tree, const alphabet::Symbol & symbol ) {
+		const std::vector < alphabet::Symbol > & content = tree.getContent ( );
+
+		return std::find ( content.begin ( ), content.end ( ), symbol ) != content.end ( );
+	}
+
+	static bool available ( const tree::PrefixBarTree &, const alphabet::Symbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::PrefixBarTree &, const alphabet::Symbol & ) {
+	}
+};
+
+template < >
+class ElementConstraint2< tree::PrefixBarTree, alphabet::Symbol, tree::BarSymbol > {
+public:
+	static bool available ( const tree::PrefixBarTree & tree, const alphabet::Symbol & symbol ) {
+		return tree.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::PrefixBarTree &, const alphabet::Symbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* PREFIX_BAR_TREE_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
index 9a573fe3d0..5afbb8baae 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "UnrankedNonlinearPattern.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -25,7 +24,7 @@
 
 namespace tree {
 
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > nonlinearVariables, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components2 < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ), std::move ( nonlinearVariables ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
 	setTree ( std::move ( pattern ) );
 }
 
@@ -35,11 +34,11 @@ UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWil
 UnrankedNonlinearPattern::UnrankedNonlinearPattern ( alphabet::Symbol subtreeWildcard, UnrankedNode pattern ) : UnrankedNonlinearPattern ( subtreeWildcard, std::set < alphabet::Symbol > { }, pattern ) {
 }
 
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( const UnrankedNonlinearPattern & other ) : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( const UnrankedNonlinearPattern & other ) : std::Components2 < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ), other.getNonlinearVariables ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
-UnrankedNonlinearPattern::UnrankedNonlinearPattern ( UnrankedNonlinearPattern && other ) noexcept : std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ), std::move ( other.accessComponent < NonlinearAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
+UnrankedNonlinearPattern::UnrankedNonlinearPattern ( UnrankedNonlinearPattern && other ) noexcept : std::Components2 < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ), std::move ( other.accessComponent < NonlinearAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
@@ -133,61 +132,6 @@ void UnrankedNonlinearPattern::compose ( std::deque < sax::Token > & out ) const
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::GeneralAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedNonlinearPattern * pattern = static_cast < const tree::UnrankedNonlinearPattern * > ( this );
-
-	return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-bool tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::GeneralAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::GeneralAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::NonlinearAlphabet >::used ( const alphabet::Symbol & ) const {
-	return false;
-}
-
-template < >
-bool tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::NonlinearAlphabet >::available ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedNonlinearPattern * pattern = static_cast < const tree::UnrankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::UnrankedNonlinearPattern::Component < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::NonlinearAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedNonlinearPattern * pattern = static_cast < const tree::UnrankedNonlinearPattern * > ( this );
-
-	if ( pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
-}
-
-template < >
-bool tree::UnrankedNonlinearPattern::Element < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::SubtreeWildcard >::available ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedNonlinearPattern * pattern = static_cast < const tree::UnrankedNonlinearPattern * > ( this );
-
-	return pattern->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::UnrankedNonlinearPattern::Element < tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::SubtreeWildcard >::valid ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedNonlinearPattern * pattern = static_cast < const tree::UnrankedNonlinearPattern * > ( this );
-
-	if ( pattern->accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
-		throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto UnrankedNonlinearPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::UnrankedNonlinearPattern > ( );
diff --git a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
index 40db0cd44a..c4f03749d7 100644
--- a/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedNonlinearPattern.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "UnrankedNode.h"
 #include "../UnrankedTreeBase.h"
 
@@ -27,7 +28,7 @@ class NonlinearAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class UnrankedNonlinearPattern : public UnrankedTreeBase, public std::Components < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
+class UnrankedNonlinearPattern : public UnrankedTreeBase, public std::Components2 < UnrankedNonlinearPattern, alphabet::Symbol, std::tuple < GeneralAlphabet, NonlinearAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::smart_ptr < UnrankedNode > pattern;
 
 public:
@@ -125,4 +126,53 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::UnrankedNonlinearPattern & pattern, const alphabet::Symbol & symbol ) {
+		return pattern.getRoot ( ).testSymbol ( symbol ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol || pattern.accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static bool available ( const tree::UnrankedNonlinearPattern &, const alphabet::Symbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::UnrankedNonlinearPattern &, const alphabet::Symbol & ) {
+	}
+};
+
+template < >
+class ComponentConstraint2< tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::NonlinearAlphabet > {
+public:
+	static bool used ( const tree::UnrankedNonlinearPattern &, const alphabet::Symbol & ) {
+		return false;
+	}
+
+	static bool available ( const tree::UnrankedNonlinearPattern & pattern, const alphabet::Symbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::UnrankedNonlinearPattern & pattern, const alphabet::Symbol & symbol) {
+		if ( pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as nonlinear variable since it is already subtree wildcard" );
+	}
+};
+
+template < >
+class ElementConstraint2< tree::UnrankedNonlinearPattern, alphabet::Symbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::UnrankedNonlinearPattern & pattern, const alphabet::Symbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::UnrankedNonlinearPattern & pattern, const alphabet::Symbol & symbol) {
+		if ( pattern.accessComponent < tree::NonlinearAlphabet > ( ).get ( ).count ( symbol ) )
+			throw tree::TreeException ( "Symbol " + ( std::string ) symbol + "cannot be set as subtree wildcard since it is already nonlinear variable" );
+	}
+};
+
+} /* namespace std */
+
 #endif /* UNRANKED_NONLINEAR_PATTERN_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.cpp b/alib2data/src/tree/unranked/UnrankedPattern.cpp
index c60e28a252..8e9d2c962f 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.cpp
+++ b/alib2data/src/tree/unranked/UnrankedPattern.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "UnrankedPattern.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -26,7 +25,7 @@
 
 namespace tree {
 
-UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
+UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, std::set < alphabet::Symbol > alphabet, UnrankedNode pattern ) : std::Components2 < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( alphabet ) ), std::make_tuple ( std::move ( subtreeWildcard ) ) ), pattern ( nullptr ) {
 	setTree ( std::move ( pattern ) );
 }
 
@@ -36,11 +35,11 @@ UnrankedPattern::UnrankedPattern ( alphabet::Symbol subtreeWildcard, UnrankedNod
 UnrankedPattern::UnrankedPattern ( const RankedPattern & other ) : UnrankedPattern ( other.getSubtreeWildcard ( ).getSymbol ( ), TreeAuxiliary::unrankSymbols ( other.getAlphabet ( ) ), other.getRoot ( ).asUnranked ( ) ) {
 }
 
-UnrankedPattern::UnrankedPattern ( const UnrankedPattern & other ) : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
+UnrankedPattern::UnrankedPattern ( const UnrankedPattern & other ) : std::Components2 < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( other.getAlphabet ( ) ), std::make_tuple ( other.getSubtreeWildcard ( ) ) ), pattern ( other.pattern ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
-UnrankedPattern::UnrankedPattern ( UnrankedPattern && other ) noexcept : std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
+UnrankedPattern::UnrankedPattern ( UnrankedPattern && other ) noexcept : std::Components2 < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::make_tuple ( std::move ( other.accessElement < SubtreeWildcard > ( ).get ( ) ) ) ), pattern ( std::move ( other.pattern ) ) {
 	this->pattern->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
@@ -131,35 +130,6 @@ void UnrankedPattern::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::UnrankedPattern::Component < tree::UnrankedPattern, alphabet::Symbol, tree::GeneralAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const tree::UnrankedPattern * pattern = static_cast < const tree::UnrankedPattern * > ( this );
-
-	return pattern->getRoot ( ).testSymbol ( symbol ) || pattern->accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
-}
-
-template < >
-bool tree::UnrankedPattern::Component < tree::UnrankedPattern, alphabet::Symbol, tree::GeneralAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void tree::UnrankedPattern::Component < tree::UnrankedPattern, alphabet::Symbol, tree::GeneralAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool tree::UnrankedPattern::Element < tree::UnrankedPattern, alphabet::Symbol, tree::SubtreeWildcard >::available ( const alphabet::Symbol & symbol ) const {
-	return static_cast < const tree::UnrankedPattern * > ( this )->accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
-}
-
-template < >
-void tree::UnrankedPattern::Element < tree::UnrankedPattern, alphabet::Symbol, tree::SubtreeWildcard >::valid ( const alphabet::Symbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto unrankedPatternParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::UnrankedPattern > ( );
diff --git a/alib2data/src/tree/unranked/UnrankedPattern.h b/alib2data/src/tree/unranked/UnrankedPattern.h
index b691ae6ea3..74e6bd25a1 100644
--- a/alib2data/src/tree/unranked/UnrankedPattern.h
+++ b/alib2data/src/tree/unranked/UnrankedPattern.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "UnrankedNode.h"
 #include "../UnrankedTreeBase.h"
 
@@ -28,7 +29,7 @@ class SubtreeWildcard;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a pattern of RegExpElement.
  */
-class UnrankedPattern : public UnrankedTreeBase, public std::Components < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
+class UnrankedPattern : public UnrankedTreeBase, public std::Components2 < UnrankedPattern, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < SubtreeWildcard > > {
 	std::smart_ptr < UnrankedNode > pattern;
 
 public:
@@ -116,4 +117,34 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::UnrankedPattern, alphabet::Symbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::UnrankedPattern & pattern, const alphabet::Symbol & symbol ) {
+		return pattern.getRoot ( ).testSymbol ( symbol ) || pattern.accessElement < tree::SubtreeWildcard > ( ).get ( ) == symbol;
+	}
+
+	static bool available ( const tree::UnrankedPattern &, const alphabet::Symbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::UnrankedPattern &, const alphabet::Symbol & ) {
+	}
+};
+
+template < >
+class ElementConstraint2< tree::UnrankedPattern, alphabet::Symbol, tree::SubtreeWildcard > {
+public:
+	static bool available ( const tree::UnrankedPattern & pattern, const alphabet::Symbol & symbol ) {
+		return pattern.accessComponent < tree::GeneralAlphabet > ( ).get ( ).count ( symbol );
+	}
+
+	static void valid ( const tree::UnrankedPattern &, const alphabet::Symbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* UNRANKED_PATTERN_H_ */
diff --git a/alib2data/src/tree/unranked/UnrankedTree.cpp b/alib2data/src/tree/unranked/UnrankedTree.cpp
index 7d44e61bed..828c9b52cb 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.cpp
+++ b/alib2data/src/tree/unranked/UnrankedTree.cpp
@@ -6,7 +6,6 @@
  */
 
 #include "UnrankedTree.h"
-#include "../TreeException.h"
 
 #include <iostream>
 #include <algorithm>
@@ -26,7 +25,7 @@
 
 namespace tree {
 
-UnrankedTree::UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( nullptr ) {
+UnrankedTree::UnrankedTree ( std::set < alphabet::Symbol > alphabet, UnrankedNode tree ) : std::Components2 < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( alphabet ) ), std::tuple < > ( ) ), tree ( nullptr ) {
 	setTree ( std::move ( tree ) );
 }
 
@@ -36,11 +35,11 @@ UnrankedTree::UnrankedTree ( UnrankedNode pattern ) : UnrankedTree ( pattern.com
 UnrankedTree::UnrankedTree ( const RankedTree & other ) : UnrankedTree ( TreeAuxiliary::unrankSymbols ( other.getAlphabet ( ) ), other.getRoot ( ).asUnranked ( ) ) {
 }
 
-UnrankedTree::UnrankedTree ( const UnrankedTree & other ) : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree ) {
+UnrankedTree::UnrankedTree ( const UnrankedTree & other ) : std::Components2 < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( other.getAlphabet ( ) ), std::tuple < > ( ) ), tree ( other.tree ) {
 	this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
-UnrankedTree::UnrankedTree ( UnrankedTree && other ) noexcept : std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( std::move ( other.tree ) ) {
+UnrankedTree::UnrankedTree ( UnrankedTree && other ) noexcept : std::Components2 < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > ( std::make_tuple ( std::move ( other.accessComponent < GeneralAlphabet > ( ).get ( ) ) ), std::tuple < > ( ) ), tree ( std::move ( other.tree ) ) {
 	this->tree->attachAlphabet ( & ( this->getAlphabet ( ) ) );
 }
 
@@ -128,24 +127,6 @@ void UnrankedTree::compose ( std::deque < sax::Token > & out ) const {
 
 } /* namespace tree */
 
-namespace std {
-
-template < >
-bool tree::UnrankedTree::Component < tree::UnrankedTree, alphabet::Symbol, tree::GeneralAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	return static_cast < const tree::UnrankedTree * > ( this )->getRoot ( ).testSymbol ( symbol );
-}
-
-template < >
-bool tree::UnrankedTree::Component < tree::UnrankedTree, alphabet::Symbol, tree::GeneralAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void tree::UnrankedTree::Component < tree::UnrankedTree, alphabet::Symbol, tree::GeneralAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-} /* namespace std */
-
 namespace alib {
 
 auto unrankedTreeParserRegister = xmlApi < tree::Tree >::ParserRegister < tree::UnrankedTree > ( );
diff --git a/alib2data/src/tree/unranked/UnrankedTree.h b/alib2data/src/tree/unranked/UnrankedTree.h
index 1c1f2dabdf..66529d4d57 100644
--- a/alib2data/src/tree/unranked/UnrankedTree.h
+++ b/alib2data/src/tree/unranked/UnrankedTree.h
@@ -10,8 +10,9 @@
 
 #include <string>
 #include <set>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 
+#include "../TreeException.h"
 #include "UnrankedNode.h"
 #include "../UnrankedTreeBase.h"
 
@@ -27,7 +28,7 @@ class GeneralAlphabet;
  * Represents regular expression parsed from the XML. Regular expression is stored
  * as a tree of RegExpElement.
  */
-class UnrankedTree : public UnrankedTreeBase, public std::Components < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
+class UnrankedTree : public UnrankedTreeBase, public std::Components2 < UnrankedTree, alphabet::Symbol, std::tuple < GeneralAlphabet >, std::tuple < > > {
 	std::smart_ptr < UnrankedNode > tree;
 
 	static std::set < alphabet::Symbol > unrankSymbols ( const std::set < alphabet::RankedSymbol > & alphabet );
@@ -113,4 +114,23 @@ public:
 
 } /* namespace tree */
 
+namespace std {
+
+template < >
+class ComponentConstraint2< tree::UnrankedTree, alphabet::Symbol, tree::GeneralAlphabet > {
+public:
+	static bool used ( const tree::UnrankedTree & tree, const alphabet::Symbol & symbol ) {
+		return tree.getRoot ( ).testSymbol ( symbol );
+	}
+
+	static bool available ( const tree::UnrankedTree &, const alphabet::Symbol & ) {
+		return true;
+	}
+
+	static void valid ( const tree::UnrankedTree &, const alphabet::Symbol & ) {
+	}
+};
+
+} /* namespace std */
+
 #endif /* UNRANKED_TREE_H_ */
-- 
GitLab