diff --git a/alib2data/src/automaton/PDA/DPDA.cpp b/alib2data/src/automaton/PDA/DPDA.cpp
index 198bd56153d03e40265f9a1f43403291401cb00f..5458244e7106a55b3d753cd49520ab25d9fe3475 100644
--- a/alib2data/src/automaton/PDA/DPDA.cpp
+++ b/alib2data/src/automaton/PDA/DPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-DPDA::DPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+DPDA::DPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 DPDA::DPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : DPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -281,114 +281,110 @@ void DPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
+class ComponentConstraint2< automaton::DPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::DPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions())
-		if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
-			return true;
+		return false;
+	}
 
-	return false;
-}
+	static bool available ( const automaton::DPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-bool automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static void valid ( const automaton::DPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-void automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+class ComponentConstraint2< automaton::DPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::DPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getInitialSymbol() == symbol)
+			return true;
 
-template < >
-bool automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions()) {
+			const auto & popSymbols = std::get<2>(transition.first);
+			const auto & pushSymbols = transition.second.second;
+			if(std::contains(popSymbols.begin(), popSymbols.end(), symbol ) || std::contains(pushSymbols.begin(), pushSymbols.end(), symbol))
+				return true;
+		}
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions()) {
-		const auto & popSymbols = std::get<2>(transition.first);
-		const auto & pushSymbols = transition.second.second;
-		if(std::contains(popSymbols.begin(), popSymbols.end(), symbol ) || std::contains(pushSymbols.begin(), pushSymbols.end(), symbol))
-			return true;
+		return false;
 	}
 
-	if(automaton->getInitialSymbol() == symbol)
+	static bool available ( const automaton::DPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::DPDA::Component < automaton::DPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::DPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::DPDA::Element < automaton::DPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::DPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::DPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::DPDA::Element < automaton::DPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::DPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::DPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::DPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions())
-		if ( state == std::get<0>(transition.first) || transition.second.first == state )
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	return false;
-}
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+			if ( state == std::get<0>(transition.first) || transition.second.first == state )
+				return true;
 
-template < >
-bool automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::DPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
+class ComponentConstraint2< automaton::DPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::DPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::DPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::DPDA::Component < automaton::DPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::DPDA::Element < automaton::DPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::DPDA * automaton = static_cast < const automaton::DPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::DPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::DPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::DPDA::Element < automaton::DPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::DPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/DPDA.h b/alib2data/src/automaton/PDA/DPDA.h
index bdd1fc294c5dc6d3db889bc95eaf7617af1aaa6b..39d0b847200128889d706a56dfe684fefe647d8d 100644
--- a/alib2data/src/automaton/PDA/DPDA.h
+++ b/alib2data/src/automaton/PDA/DPDA.h
@@ -12,7 +12,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -34,7 +34,7 @@ class InitialState;
  * if $\delta (q, a, \alpha) \neq \emptyset$, $\delta (q, a, \beta) \neq \emptyset$ and $\alpha \neq \beta$, then $\alpha$ is not suffix of $\beta$ and $\beta$ is not suffix of $\alpha$ (formally $\gamma \alpha \neq \beta and \alpha \neq \gamma \beta$).
  * if $\delta(q, a, \alpha) \neq \emptyset$, $\delta (q, \varepsilon, \beta) \neq \emptyset$, then $\alpha$ is not suffix of $\beta$ and $\beta$ is not suffix of $\alpha$ (fornally $\gamma \alpha \neq \beta and \alpha \neq \gamma \beta$).
  */
-class DPDA : public AutomatonBase, public std::Components < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class DPDA : public AutomatonBase, public std::Components2 < DPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::pair < State, std::vector < alphabet::Symbol > > > transitions;
 
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp b/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
index d17a041651283bd4bd4400eca339725024623d8d..de733fa3a57032ce1f4d64a327c8ceacac07faf3 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-InputDrivenDPDA::InputDrivenDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenDPDA::InputDrivenDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 InputDrivenDPDA::InputDrivenDPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -251,114 +251,110 @@ void InputDrivenDPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
+class ComponentConstraint2< automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::InputDrivenDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& transition : automaton.getTransitions())
+			if (transition.first.second == symbol)
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& transition : automaton->getTransitions())
-		if (transition.first.second == symbol)
-			return true;
-
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::InputDrivenDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
+class ComponentConstraint2< automaton::InputDrivenDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::InputDrivenDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
+			if (std::find(pushdownStoreOperation.second.first.begin(), pushdownStoreOperation.second.first.end(), symbol) != pushdownStoreOperation.second.first.end())
+				return true;
+			if (std::find(pushdownStoreOperation.second.second.begin(), pushdownStoreOperation.second.second.end(), symbol) != pushdownStoreOperation.second.second.end())
+				return true;
+		}
 
-	for (const auto& pushdownStoreOperation : automaton->getPushdownStoreOperations()) {
-		if (std::find(pushdownStoreOperation.second.first.begin(), pushdownStoreOperation.second.first.end(), symbol) != pushdownStoreOperation.second.first.end())
-			return true;
-		if (std::find(pushdownStoreOperation.second.second.begin(), pushdownStoreOperation.second.second.end(), symbol) != pushdownStoreOperation.second.second.end())
+		if(automaton.getInitialSymbol() == symbol)
 			return true;
+
+		return false;
 	}
 
-	if(automaton->getInitialSymbol() == symbol)
+	static bool available ( const automaton::InputDrivenDPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenDPDA::Element < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::InputDrivenDPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::InputDrivenDPDA::Element < automaton::InputDrivenDPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::InputDrivenDPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& t : automaton->getTransitions())
-		if (t.first.first == state || t.second == state)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	return false;
-}
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& t : automaton.getTransitions())
+			if (t.first.first == state || t.second == state)
+				return true;
 
-template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
+class ComponentConstraint2< automaton::InputDrivenDPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::InputDrivenDPDA::Component < automaton::InputDrivenDPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenDPDA::Element < automaton::InputDrivenDPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::InputDrivenDPDA * automaton = static_cast < const automaton::InputDrivenDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::InputDrivenDPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::InputDrivenDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::InputDrivenDPDA::Element < automaton::InputDrivenDPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::InputDrivenDPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/InputDrivenDPDA.h b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
index 6335bc29cb08b102b97bdcc16cd6da5eaf414b5f..45b15a91ccbd1c39188010d6bc38acae6611d31d 100644
--- a/alib2data/src/automaton/PDA/InputDrivenDPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenDPDA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -28,7 +28,7 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class InputDrivenDPDA : public AutomatonBase, public std::Components < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenDPDA : public AutomatonBase, public std::Components2 < InputDrivenDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, State > transitions;
 	std::map < alphabet::Symbol, std::pair < std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > inputSymbolToPushdownStoreOperation;
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp b/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
index 6a870fe53f4761fe1fd38362d714bc8a6575e25f..2ebd78b3d8465a221bca94a01f0c64b8790d5c5a 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-InputDrivenNPDA::InputDrivenNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+InputDrivenNPDA::InputDrivenNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 InputDrivenNPDA::InputDrivenNPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : InputDrivenNPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -248,114 +248,110 @@ void InputDrivenNPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State>>& transition : automaton->getTransitions())
-		if (transition.first.second == symbol)
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::InputDrivenNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State>>& transition : automaton.getTransitions())
+			if (transition.first.second == symbol)
+				return true;
+
+		return false;
+	}
 
-template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::InputDrivenNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
+class ComponentConstraint2< automaton::InputDrivenNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::InputDrivenNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const auto& pushdownStoreOperation : automaton.getPushdownStoreOperations()) {
+			if (std::find(pushdownStoreOperation.second.first.begin(), pushdownStoreOperation.second.first.end(), symbol) != pushdownStoreOperation.second.first.end())
+				return true;
+			if (std::find(pushdownStoreOperation.second.second.begin(), pushdownStoreOperation.second.second.end(), symbol) != pushdownStoreOperation.second.second.end())
+				return true;
+		}
 
-	for (const auto& pushdownStoreOperation : automaton->getPushdownStoreOperations()) {
-		if (std::find(pushdownStoreOperation.second.first.begin(), pushdownStoreOperation.second.first.end(), symbol) != pushdownStoreOperation.second.first.end())
-			return true;
-		if (std::find(pushdownStoreOperation.second.second.begin(), pushdownStoreOperation.second.second.end(), symbol) != pushdownStoreOperation.second.second.end())
+		if(automaton.getInitialSymbol() == symbol)
 			return true;
+
+		return false;
 	}
 
-	if(automaton->getInitialSymbol() == symbol)
+	static bool available ( const automaton::InputDrivenNPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenNPDA::Element < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::InputDrivenNPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::InputDrivenNPDA::Element < automaton::InputDrivenNPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::InputDrivenNPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& transition : automaton->getTransitions())
-		if (transition.first.first == state || transition.second.find(state) != transition.second.end())
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	return false;
-}
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& transition : automaton.getTransitions())
+			if (transition.first.first == state || transition.second.find(state) != transition.second.end())
+				return true;
 
-template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
+class ComponentConstraint2< automaton::InputDrivenNPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::InputDrivenNPDA::Component < automaton::InputDrivenNPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::InputDrivenNPDA::Element < automaton::InputDrivenNPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::InputDrivenNPDA * automaton = static_cast < const automaton::InputDrivenNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::InputDrivenNPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::InputDrivenNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::InputDrivenNPDA::Element < automaton::InputDrivenNPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::InputDrivenNPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/InputDrivenNPDA.h b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
index 8bf17b533f94ffa8e983f5d2ae2ded1ee7730b65..6cb1609f779fca6b09156882ee26de8ebd6ef8cc 100644
--- a/alib2data/src/automaton/PDA/InputDrivenNPDA.h
+++ b/alib2data/src/automaton/PDA/InputDrivenNPDA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -28,7 +28,7 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class InputDrivenNPDA : public AutomatonBase, public std::Components < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class InputDrivenNPDA : public AutomatonBase, public std::Components2 < InputDrivenNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;
 	std::map < alphabet::Symbol, std::pair < std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > inputSymbolToPushdownStoreOperation;
diff --git a/alib2data/src/automaton/PDA/NPDA.cpp b/alib2data/src/automaton/PDA/NPDA.cpp
index 82fdedf5cfafbe8f0bbcb50ccc8c3e4a7b9c6e17..e5dbda5f32e42b15042dabe74a01ec9a2ba72e3e 100644
--- a/alib2data/src/automaton/PDA/NPDA.cpp
+++ b/alib2data/src/automaton/PDA/NPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-NPDA::NPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDA::NPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 NPDA::NPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : NPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -187,121 +187,117 @@ void NPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
+class ComponentConstraint2< automaton::NPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::NPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions())
-		if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
-			return true;
+		return false;
+	}
 
-	return false;
-}
+	static bool available ( const automaton::NPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-bool automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static void valid ( const automaton::NPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-void automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+class ComponentConstraint2< automaton::NPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::NPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getInitialSymbol() == symbol)
+			return true;
 
-template < >
-bool automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
+				if (symbol == popSymbol)
+					return true;
 
-	if(automaton->getInitialSymbol() == symbol)
-		return true;
+			for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+				if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
+					return true;
+		}
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
-			if (symbol == popSymbol)
-				return true;
+		return false;
+	}
 
-		for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
-			if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
-				return true;
+	static bool available ( const automaton::NPDA &, const alphabet::Symbol & ) {
+		return true;
 	}
 
-	return false;
-}
+	static void valid ( const automaton::NPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+class ElementConstraint2< automaton::NPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::NPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::NPDA::Component < automaton::NPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::NPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::NPDA::Element < automaton::NPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ComponentConstraint2< automaton::NPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::NPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-template < >
-void automaton::NPDA::Element < automaton::NPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+		if ( automaton.getFinalStates ( ).count ( state ) )
+			return true;
 
-template < >
-bool automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			if (state == std::get<0>(transition.first))
+				return true;
+			for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+				if(target.first == state)
+					return true;
+		}
 
-	if ( automaton->getInitialState ( ) == state )
-		return true;
+		return false;
+	}
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
+	static bool available ( const automaton::NPDA &, const automaton::State & ) {
 		return true;
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		if (state == std::get<0>(transition.first))
-			return true;
-		for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
-			if(target.first == state)
-				return true;
 	}
 
-	return false;
-}
-
-template < >
-bool automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
-
-template < >
-void automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
-
-template < >
-bool automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
+class ComponentConstraint2< automaton::NPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::NPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::NPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::NPDA::Component < automaton::NPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::NPDA::Element < automaton::NPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::NPDA * automaton = static_cast < const automaton::NPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::NPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::NPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::NPDA::Element < automaton::NPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::NPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/NPDA.h b/alib2data/src/automaton/PDA/NPDA.h
index b9622b4501b09abdf97d7919cc509cdb43779754..4ad36c2696610d7501c9cff0a8bded0c1b9ebd32 100644
--- a/alib2data/src/automaton/PDA/NPDA.h
+++ b/alib2data/src/automaton/PDA/NPDA.h
@@ -12,7 +12,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -30,7 +30,7 @@ class InitialState;
 /**
  * Push Down Automaton
  */
-class NPDA : public AutomatonBase, public std::Components < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDA : public AutomatonBase, public std::Components2 < NPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > transitions;
 
diff --git a/alib2data/src/automaton/PDA/NPDTA.cpp b/alib2data/src/automaton/PDA/NPDTA.cpp
index 0f36e9f6dc740e3f0da095762c0dcd022df37518..632ec9510ae5ed003653970b2cd6718af61809f9 100644
--- a/alib2data/src/automaton/PDA/NPDTA.cpp
+++ b/alib2data/src/automaton/PDA/NPDTA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-NPDTA::NPDTA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( outputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NPDTA::NPDTA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > outputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( outputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 NPDTA::NPDTA(State initialState, alphabet::Symbol initialPushdownSymbol) : NPDTA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -222,143 +222,138 @@ void NPDTA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions())
-		if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
-			return true;
-
-	return false;
-}
-
-template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::OutputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions())
-		for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
-			if (std::find(std::get<2>(target).begin(), std::get<2>(target).end(), symbol) != std::get<2>(target).end())
+class ComponentConstraint2< automaton::NPDTA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
 				return true;
 
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::OutputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::OutputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
+class ComponentConstraint2< automaton::NPDTA, alphabet::Symbol, automaton::OutputAlphabet > {
+public:
+	static bool used ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+			for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+				if (std::find(std::get<2>(target).begin(), std::get<2>(target).end(), symbol) != std::get<2>(target).end())
+					return true;
+
+		return false;
+	}
 
-	if(automaton->getInitialSymbol() == symbol)
+	static bool available ( const automaton::NPDTA &, const alphabet::Symbol & ) {
 		return true;
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
-			if (symbol == popSymbol)
-				return true;
-
-		for (const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
-			if (std::find(std::get<1>(target).begin(), std::get<1>(target).end(), symbol) != std::get<1>(target).end())
-				return true;
 	}
 
-	return false;
-}
+	static void valid ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+class ComponentConstraint2< automaton::NPDTA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getInitialSymbol() == symbol)
+			return true;
 
-template < >
-void automaton::NPDTA::Component < automaton::NPDTA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			for (const alphabet::Symbol& popSymbol : std::get<2>(transition.first))
+				if (symbol == popSymbol)
+					return true;
 
-template < >
-bool automaton::NPDTA::Element < automaton::NPDTA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
+			for (const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+				if (std::find(std::get<1>(target).begin(), std::get<1>(target).end(), symbol) != std::get<1>(target).end())
+					return true;
+		}
 
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+		return false;
+	}
 
-template < >
-void automaton::NPDTA::Element < automaton::NPDTA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static bool available ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+		return true;
+	}
+
+	static void valid ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
+class ElementConstraint2< automaton::NPDTA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::NPDTA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-	if ( automaton->getInitialState ( ) == state )
-		return true;
+	static void valid ( const automaton::NPDTA &, const alphabet::Symbol & ) {
+	}
+};
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+template < >
+class ComponentConstraint2< automaton::NPDTA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		if (state == std::get<0>(transition.first))
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
-			if(std::get<0>(target) == state)
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, std::vector<alphabet::Symbol> >, std::set<std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			if (state == std::get<0>(transition.first))
 				return true;
-	}
 
-	return false;
-}
+			for(const std::tuple<automaton::State, std::vector<alphabet::Symbol>, std::vector<alphabet::Symbol> >& target : transition.second)
+				if(std::get<0>(target) == state)
+					return true;
+		}
 
-template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::NPDTA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
+class ComponentConstraint2< automaton::NPDTA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::NPDTA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::NPDTA::Component < automaton::NPDTA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::NPDTA::Element < automaton::NPDTA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::NPDTA * automaton = static_cast < const automaton::NPDTA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::NPDTA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::NPDTA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::NPDTA::Element < automaton::NPDTA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::NPDTA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/NPDTA.h b/alib2data/src/automaton/PDA/NPDTA.h
index d2ee8a708903da0fae70b24015f1be9e7393475d..9e3bbbcb7d1049c288dd6c0ba56175b6b164f648 100644
--- a/alib2data/src/automaton/PDA/NPDTA.h
+++ b/alib2data/src/automaton/PDA/NPDTA.h
@@ -12,7 +12,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -31,7 +31,7 @@ class InitialState;
 /**
  * Push Down Translation Automaton
  */
-class NPDTA : public AutomatonBase, public std::Components < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NPDTA : public AutomatonBase, public std::Components2 < NPDTA, alphabet::Symbol, std::tuple < InputAlphabet, OutputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, std::vector < alphabet::Symbol > >, std::set < std::tuple < State, std::vector < alphabet::Symbol >, std::vector < alphabet::Symbol > > > > transitions;
 
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
index f7698552cb5c341d84805ca42da9fabf53dd0e1f..0417a377362e96988224d2732fdf0963c1fa1fda 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components2 < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 RealTimeHeightDeterministicDPDA::RealTimeHeightDeterministicDPDA(State initialState, alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
@@ -441,131 +441,127 @@ void RealTimeHeightDeterministicDPDA::composeTransitions(std::deque<sax::Token>&
 namespace std {
 
 template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
-			return true;
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
-			return true;
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton.getLocalTransitions())
+			if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton->getLocalTransitions())
-		if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
-			return true;
-
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (symbol == callTransition.second.second)
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (symbol == callTransition.second.second)
+				return true;
+
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<2>(returnTransition.first))
+				return true;
+
+		if(automaton.getBottomOfTheStackSymbol() == symbol)
 			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<2>(returnTransition.first))
-			return true;
+		return false;
+	}
 
-	if(automaton->getBottomOfTheStackSymbol() == symbol)
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Element < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol > {
+public:
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicDPDA::Element < automaton::RealTimeHeightDeterministicDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
-
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (state == callTransition.first.first || callTransition.second.first == state)
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
 			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton->getLocalTransitions())
-		if (state == localTransition.first.first || localTransition.second == state)
-			return true;
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (state == callTransition.first.first || callTransition.second.first == state)
+				return true;
 
-	return false;
-}
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
+				return true;
 
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
-
-template < >
-void automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, automaton::State>& localTransition : automaton.getLocalTransitions())
+			if (state == localTransition.first.first || localTransition.second == state)
+				return true;
 
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+		return true;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::RealTimeHeightDeterministicDPDA::Component < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicDPDA::Element < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicDPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicDPDA * > ( this );
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::RealTimeHeightDeterministicDPDA::Element < automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+class ElementConstraint2< automaton::RealTimeHeightDeterministicDPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::RealTimeHeightDeterministicDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
+
+	static void valid ( const automaton::RealTimeHeightDeterministicDPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
index bc10518e1154644cf49c1980a51d5db51c6537be..d5fd1cc627bb355f400f27e3e2809a41090f5ecc 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicDPDA.h
@@ -11,7 +11,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -30,7 +30,7 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class RealTimeHeightDeterministicDPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class RealTimeHeightDeterministicDPDA : public AutomatonBase, public std::Components2 < RealTimeHeightDeterministicDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::pair < State, alphabet::Symbol > > callTransitions;
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, State > returnTransitions;
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
index 7ef3543015f41e276b760a210e36fa6fae39c907..be27a9d2a5d04c33eb96cd6f472de3635e205829 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
+RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components2 < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > { } ) {
 }
 
 RealTimeHeightDeterministicNPDA::RealTimeHeightDeterministicNPDA(alphabet::Symbol bottomOfTheStackSymbol) : RealTimeHeightDeterministicNPDA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < State > {}, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
@@ -328,152 +328,147 @@ void RealTimeHeightDeterministicNPDA::composeTransitions(std::deque<sax::Token>&
 namespace std {
 
 template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions())
-		if (callTransition.first.second.is<alphabet::Symbol>() && symbol == callTransition.first.second.get<alphabet::Symbol>())
-			return true;
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+			if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton->getReturnTransitions())
-		if (std::get<1>(returnTransition.first).is<alphabet::Symbol>() && symbol == std::get<1>(returnTransition.first).get<alphabet::Symbol>())
-			return true;
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions())
+			if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton->getLocalTransitions())
-		if (localTransition.first.second.is<alphabet::Symbol>() && symbol == localTransition.first.second.get<alphabet::Symbol>())
-			return true;
+		return false;
+	}
 
-	return false;
-}
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-void automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getBottomOfTheStackSymbol() == symbol)
+			return true;
 
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
+				if (symbol == to.second)
+					return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions())
-		for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
-			if (symbol == to.second)
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<2>(returnTransition.first))
-			return true;
+		return false;
+	}
 
-	if(automaton->getBottomOfTheStackSymbol() == symbol)
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Element < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol > {
+public:
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicNPDA::Element < automaton::RealTimeHeightDeterministicNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
-
-	if ( automaton->getInitialStates ( ).count ( state ) )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialStates ( ).count ( state ) )
+			return true;
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions()) {
-		if (state == callTransition.first.first)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second)
-			if(target.first == state)
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
+			if (state == callTransition.first.first)
 				return true;
-	}
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton->getReturnTransitions()) {
-		if (state == std::get<0>(returnTransition.first))
-			return true;
+			for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second)
+				if(target.first == state)
+					return true;
+		}
 
-		for(const automaton::State& target : returnTransition.second)
-			if(target == state)
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions()) {
+			if (state == std::get<0>(returnTransition.first))
 				return true;
-	}
 
-	for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton->getLocalTransitions()) {
-		if (state == localTransition.first.first)
-			return true;
+			for(const automaton::State& target : returnTransition.second)
+				if(target == state)
+					return true;
+		}
 
-		for(const automaton::State& target : localTransition.second)
-			if(target == state)
+		for (const std::pair<const std::pair<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions()) {
+			if (state == localTransition.first.first)
 				return true;
-	}
 
-	return false;
-}
+			for(const automaton::State& target : localTransition.second)
+				if(target == state)
+					return true;
+		}
 
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::InitialStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::InitialStates >::available ( const automaton::State & state ) const {
-	const automaton::RealTimeHeightDeterministicNPDA * automaton = static_cast < const automaton::RealTimeHeightDeterministicNPDA * > ( this );
+class ComponentConstraint2< automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::InitialStates > {
+public:
+	static bool used ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::RealTimeHeightDeterministicNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::RealTimeHeightDeterministicNPDA::Component < automaton::RealTimeHeightDeterministicNPDA, automaton::State, automaton::InitialStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::RealTimeHeightDeterministicNPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
index d24f0aa52bcad831b6087089665e56ad2c35d6f6..fd10db0a0e6a025086bb5b9410afaf2100f156ef 100644
--- a/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
+++ b/alib2data/src/automaton/PDA/RealTimeHeightDeterministicNPDA.h
@@ -11,6 +11,7 @@
 #include <map>
 #include <vector>
 #include <variant>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -29,7 +30,7 @@ class InitialStates;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class RealTimeHeightDeterministicNPDA : public AutomatonBase, public std::Components < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class RealTimeHeightDeterministicNPDA : public AutomatonBase, public std::Components2 < RealTimeHeightDeterministicNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < std::pair < State, alphabet::Symbol > > > callTransitions;
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < State > > returnTransitions;
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.cpp b/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
index e08b5053136fedb5a6762ec3a47066410c38adf8..798f22cc1fc9cdfa98878631d1745db9a507b4b7 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-SinglePopDPDA::SinglePopDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopDPDA::SinglePopDPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 SinglePopDPDA::SinglePopDPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -228,111 +228,107 @@ void SinglePopDPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
+class ComponentConstraint2< automaton::SinglePopDPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::SinglePopDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
+				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions())
-		if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
-			return true;
-
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::SinglePopDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::SinglePopDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions())
-		if (symbol == std::get<2>(transition.first) || std::find(transition.second.second.begin(), transition.second.second.end(), symbol) != transition.second.second.end())
+class ComponentConstraint2< automaton::SinglePopDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::SinglePopDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+			if (symbol == std::get<2>(transition.first) || std::find(transition.second.second.begin(), transition.second.second.end(), symbol) != transition.second.second.end())
+				return true;
+
+		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-	if(automaton->getInitialSymbol() == symbol)
-		return true;
-
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::SinglePopDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::SinglePopDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopDPDA::Element < automaton::SinglePopDPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::SinglePopDPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::SinglePopDPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::SinglePopDPDA::Element < automaton::SinglePopDPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::SinglePopDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::SinglePopDPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton->getTransitions())
-		if (state == std::get<0>(transition.first) || transition.second.first == state)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	return false;
-}
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::pair<automaton::State, std::vector<alphabet::Symbol> > >& transition : automaton.getTransitions())
+			if (state == std::get<0>(transition.first) || transition.second.first == state)
+				return true;
 
-template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
+class ComponentConstraint2< automaton::SinglePopDPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::SinglePopDPDA::Component < automaton::SinglePopDPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopDPDA::Element < automaton::SinglePopDPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::SinglePopDPDA * automaton = static_cast < const automaton::SinglePopDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::SinglePopDPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::SinglePopDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::SinglePopDPDA::Element < automaton::SinglePopDPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::SinglePopDPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/SinglePopDPDA.h b/alib2data/src/automaton/PDA/SinglePopDPDA.h
index c95d5b2b506e6bff1b91b27e3a9b259907f03f12..fedeb6eecc848bfbceeda2b9d5a8b5cccdd94cad 100644
--- a/alib2data/src/automaton/PDA/SinglePopDPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopDPDA.h
@@ -12,7 +12,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -34,7 +34,7 @@ class InitialState;
  * if $\delta (q, a, r) \neq \emptyset$, $\delta (q, a, s) \neq \emptyset$ then $r \neq s$.
  * if $\delta(q, a, r) \neq \emptyset$, $\delta (q, \varepsilon, s) \neq \emptyset$, then $r \neq s$.
  */
-class SinglePopDPDA : public AutomatonBase, public std::Components < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopDPDA : public AutomatonBase, public std::Components2 < SinglePopDPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::pair < State, std::vector < alphabet::Symbol > > > transitions;
 
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.cpp b/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
index 6bf2395ec6d84bf752eb998eef0fc7d2f10d2278..8f1ce76ca5bc57a21ac5f2e0299bb8c05035be4a 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.cpp
@@ -19,7 +19,7 @@
 
 namespace automaton {
 
-SinglePopNPDA::SinglePopNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+SinglePopNPDA::SinglePopNPDA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol initialSymbol, std::set < State > finalStates ) : std::Components2 < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( initialSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 SinglePopNPDA::SinglePopNPDA(State initialState, alphabet::Symbol initialPushdownSymbol) : SinglePopNPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { initialPushdownSymbol }, initialState, initialPushdownSymbol, std::set < automaton::State > { }) {
@@ -191,121 +191,117 @@ void SinglePopNPDA::composeTransitions(std::deque<sax::Token>& out) const {
 namespace std {
 
 template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions())
-		if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
-			return true;
+class ComponentConstraint2< automaton::SinglePopNPDA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::SinglePopNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions())
+			if (std::get<1>(transition.first).is<alphabet::Symbol>() && symbol == std::get<1>(transition.first).get<alphabet::Symbol>())
+				return true;
 
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::SinglePopNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::SinglePopNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
-
-	if(automaton->getInitialSymbol() == symbol)
-		return true;
-
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		if (symbol == std::get<2>(transition.first))
+class ComponentConstraint2< automaton::SinglePopNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::SinglePopNPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getInitialSymbol() == symbol)
 			return true;
 
-		for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
-			if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			if (symbol == std::get<2>(transition.first))
 				return true;
-	}
 
-	return false;
-}
-
-template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+			for (const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+				if (std::find(target.second.begin(), target.second.end(), symbol) != target.second.end())
+					return true;
+		}
 
-template < >
-bool automaton::SinglePopNPDA::Element < automaton::SinglePopNPDA, alphabet::Symbol, automaton::InitialSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+	static bool available ( const automaton::SinglePopNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::SinglePopNPDA::Element < automaton::SinglePopNPDA, alphabet::Symbol, automaton::InitialSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::SinglePopNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
+class ElementConstraint2< automaton::SinglePopNPDA, alphabet::Symbol, automaton::InitialSymbol > {
+public:
+	static bool available ( const automaton::SinglePopNPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-	if ( automaton->getInitialState ( ) == state )
-		return true;
+	static void valid ( const automaton::SinglePopNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+template < >
+class ComponentConstraint2< automaton::SinglePopNPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton->getTransitions()) {
-		if (state == std::get<0>(transition.first))
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-		for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
-			if(target.first == state)
+		for (const std::pair<const std::tuple<automaton::State, std::variant<::string::Epsilon, alphabet::Symbol>, alphabet::Symbol>, std::set<std::pair<automaton::State, std::vector<alphabet::Symbol> > > >& transition : automaton.getTransitions()) {
+			if (state == std::get<0>(transition.first))
 				return true;
-	}
 
-	return false;
-}
+			for(const std::pair<automaton::State, std::vector<alphabet::Symbol> >& target : transition.second)
+				if(target.first == state)
+					return true;
+		}
 
-template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
+class ComponentConstraint2< automaton::SinglePopNPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::SinglePopNPDA::Component < automaton::SinglePopNPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::SinglePopNPDA::Element < automaton::SinglePopNPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::SinglePopNPDA * automaton = static_cast < const automaton::SinglePopNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::SinglePopNPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::SinglePopNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::SinglePopNPDA::Element < automaton::SinglePopNPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::SinglePopNPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/SinglePopNPDA.h b/alib2data/src/automaton/PDA/SinglePopNPDA.h
index 4dc2e75ce0a5d368d542bd27b4a14e2b6c09f1b8..3434a889c843803f78ccaa7f4107cf05e1bb7636 100644
--- a/alib2data/src/automaton/PDA/SinglePopNPDA.h
+++ b/alib2data/src/automaton/PDA/SinglePopNPDA.h
@@ -12,7 +12,7 @@
 #include <map>
 #include <vector>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -30,7 +30,7 @@ class InitialState;
 /**
  * Push Down Automaton
  */
-class SinglePopNPDA : public AutomatonBase, public std::Components < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class SinglePopNPDA : public AutomatonBase, public std::Components2 < SinglePopNPDA, alphabet::Symbol, std::tuple < InputAlphabet, PushdownStoreAlphabet >, std::tuple < InitialSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::tuple < State, std::variant < string::Epsilon, alphabet::Symbol >, alphabet::Symbol >, std::set < std::pair < State, std::vector < alphabet::Symbol > > > > transitions;
 
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
index 58ad4a44ef2dc6559a5b9ea68bd6e88990d567ad..6c01077d60da3c56b777d4522b0f112e2b9f88b7 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.cpp
@@ -19,7 +19,7 @@
 
 namespace automaton {
 
-VisiblyPushdownDPDA::VisiblyPushdownDPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+VisiblyPushdownDPDA::VisiblyPushdownDPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, State initialState, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components2 < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 VisiblyPushdownDPDA::VisiblyPushdownDPDA(State initialState, alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownDPDA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, initialState, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
@@ -343,181 +343,169 @@ void VisiblyPushdownDPDA::composeTransitions(std::deque<sax::Token>& out) const
 namespace std {
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::CallAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::CallAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (symbol == callTransition.first.second)
+				return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (symbol == callTransition.first.second)
-			return true;
-
-	return false;
-}
-
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::CallAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::CallAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getLocalInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
-	if(automaton->getReturnInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getLocalInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
+		if(automaton.getReturnInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::ReturnAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<1>(returnTransition.first))
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::ReturnAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<1>(returnTransition.first))
+				return true;
 
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::ReturnAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::ReturnAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getLocalInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
-	if(automaton->getCallInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getLocalInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
+		if(automaton.getCallInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::LocalAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton->getLocalTransitions())
-		if (symbol == localTransition.first.second)
-			return true;
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::LocalAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton.getLocalTransitions())
+			if (symbol == localTransition.first.second)
+				return true;
 
-	return false;
-}
-
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::LocalAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::LocalAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getReturnInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
-	if(automaton->getCallInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getReturnInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
+		if(automaton.getCallInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (symbol == callTransition.second.second)
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (symbol == callTransition.second.second)
+				return true;
+
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<2>(returnTransition.first))
+				return true;
+
+		if(automaton.getBottomOfTheStackSymbol() == symbol)
 			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<2>(returnTransition.first))
-			return true;
+		return false;
+	}
 
-	if(automaton->getBottomOfTheStackSymbol() == symbol)
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	return false;
-}
-
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Element < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol > {
+public:
+	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::VisiblyPushdownDPDA::Element < automaton::VisiblyPushdownDPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton->getCallTransitions())
-		if (state == callTransition.first.first || callTransition.second.first == state)
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
 			return true;
 
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton->getReturnTransitions())
-		if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton->getLocalTransitions())
-		if (state == localTransition.first.first || localTransition.second == state)
-			return true;
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::pair<automaton::State, alphabet::Symbol> >& callTransition : automaton.getCallTransitions())
+			if (state == callTransition.first.first || callTransition.second.first == state)
+				return true;
 
-	return false;
-}
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, automaton::State>& returnTransition : automaton.getReturnTransitions())
+			if (state == std::get<0>(returnTransition.first) || returnTransition.second == state)
+				return true;
 
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& localTransition : automaton.getLocalTransitions())
+			if (state == localTransition.first.first || localTransition.second == state)
+				return true;
 
-template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
-
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+		return true;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::VisiblyPushdownDPDA::Component < automaton::VisiblyPushdownDPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+class ComponentConstraint2< automaton::VisiblyPushdownDPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-bool automaton::VisiblyPushdownDPDA::Element < automaton::VisiblyPushdownDPDA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownDPDA * automaton = static_cast < const automaton::VisiblyPushdownDPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::VisiblyPushdownDPDA::Element < automaton::VisiblyPushdownDPDA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+class ElementConstraint2< automaton::VisiblyPushdownDPDA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::VisiblyPushdownDPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
+
+	static void valid ( const automaton::VisiblyPushdownDPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
index c126dff616790d177fc33c17c5dfd3cf45d771af..847f4c996ff1c96e01b923cb3668b10185123235 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownDPDA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -30,7 +30,7 @@ class InitialState;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class VisiblyPushdownDPDA : public AutomatonBase, public std::Components < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class VisiblyPushdownDPDA : public AutomatonBase, public std::Components2 < VisiblyPushdownDPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, std::pair < State, alphabet::Symbol > > callTransitions;
 	std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, State > returnTransitions;
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
index 3113c5bd6d29d1020b361c968356e66a5ae57b95..847b661860c19b5805496dc2b7e7f4be4b4af731 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.cpp
@@ -19,7 +19,7 @@
 
 namespace automaton {
 
-VisiblyPushdownNPDA::VisiblyPushdownNPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+VisiblyPushdownNPDA::VisiblyPushdownNPDA ( std::set < State > states, std::set < alphabet::Symbol > callAlphabet, std::set < alphabet::Symbol > returnAlphabet, std::set < alphabet::Symbol > localAlphabet, std::set < alphabet::Symbol > pushdownStoreAlphabet, std::set < State > initialStates, alphabet::Symbol bottomOfTheStackSymbol, std::set < State > finalStates ) : std::Components2 < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( callAlphabet ), std::move ( returnAlphabet ), std::move ( localAlphabet ), std::move ( pushdownStoreAlphabet ) ), std::make_tuple ( std::move ( bottomOfTheStackSymbol ) ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 VisiblyPushdownNPDA::VisiblyPushdownNPDA(alphabet::Symbol bottomOfTheStackSymbol) : VisiblyPushdownNPDA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { }, std::set < alphabet::Symbol > { bottomOfTheStackSymbol }, std::set < State > { }, bottomOfTheStackSymbol, std::set < automaton::State > { }) {
@@ -275,202 +275,189 @@ void VisiblyPushdownNPDA::composeTransitions(std::deque<sax::Token>& out) const
 namespace std {
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::CallAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions())
-		if (symbol == callTransition.first.second)
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::CallAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			if (symbol == callTransition.first.second)
+				return true;
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::CallAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::CallAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getLocalInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
-	if(automaton->getReturnInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getLocalInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
+		if(automaton.getReturnInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::ReturnAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set < automaton::State> >& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<1>(returnTransition.first))
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::ReturnAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set < automaton::State> >& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<1>(returnTransition.first))
+				return true;
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::ReturnAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::ReturnAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getLocalInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
-	if(automaton->getCallInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getLocalInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in local alphabet");
+		if(automaton.getCallInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::LocalAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < automaton::State >>& localTransition : automaton->getLocalTransitions())
-		if (symbol == localTransition.first.second)
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::LocalAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set < automaton::State >>& localTransition : automaton.getLocalTransitions())
+			if (symbol == localTransition.first.second)
+				return true;
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::LocalAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::LocalAlphabet >::valid ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	if(automaton->getReturnInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
-	if(automaton->getCallInputAlphabet().count(symbol))
-		throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		if(automaton.getReturnInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in return alphabet");
+		if(automaton.getCallInputAlphabet().count(symbol))
+			throw automaton::AutomatonException("Input symbol " + (std::string) symbol + " already in call alphabet");
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions())
-		for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
-			if (symbol == to.second)
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions())
+			for(const std::pair<automaton::State, alphabet::Symbol>& to : callTransition.second)
+				if (symbol == to.second)
+					return true;
+
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions())
+			if (symbol == std::get<2>(returnTransition.first))
 				return true;
 
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton->getReturnTransitions())
-		if (symbol == std::get<2>(returnTransition.first))
+		if(automaton.getBottomOfTheStackSymbol() == symbol)
 			return true;
 
-	if(automaton->getBottomOfTheStackSymbol() == symbol)
-		return true;
-
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::PushdownStoreAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Element < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::available ( const alphabet::Symbol & symbol ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
-}
+class ElementConstraint2< automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol > {
+public:
+	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const alphabet::Symbol & symbol ) {
+		return automaton.accessComponent < automaton::PushdownStoreAlphabet > ( ).get ( ).count ( symbol );
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Element < automaton::VisiblyPushdownNPDA, alphabet::Symbol, automaton::BottomOfTheStackSymbol >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	if ( automaton->getInitialStates ( ).count ( state ) )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialStates ( ).count ( state ) )
+			return true;
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton->getCallTransitions()) {
-		if (state == callTransition.first.first)
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
-		for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second) {
-			if(target.first == state)
+
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<std::pair<automaton::State, alphabet::Symbol> > >& callTransition : automaton.getCallTransitions()) {
+			if (state == callTransition.first.first)
 				return true;
+			for(const std::pair<automaton::State, alphabet::Symbol>& target : callTransition.second) {
+				if(target.first == state)
+					return true;
+			}
 		}
-	}
 
-	for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton->getReturnTransitions()) {
-		if (state == std::get<0>(returnTransition.first))
-			return true;
-		for(const automaton::State& target : returnTransition.second) {
-			if(target == state)
+		for (const std::pair<const std::tuple<automaton::State, alphabet::Symbol, alphabet::Symbol>, std::set<automaton::State> >& returnTransition : automaton.getReturnTransitions()) {
+			if (state == std::get<0>(returnTransition.first))
 				return true;
+			for(const automaton::State& target : returnTransition.second) {
+				if(target == state)
+					return true;
+			}
 		}
-	}
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& localTransition : automaton->getLocalTransitions()) {
-		if (state == localTransition.first.first)
-			return true;
-		for(const automaton::State& target : localTransition.second) {
-			if(target == state)
+		for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& localTransition : automaton.getLocalTransitions()) {
+			if (state == localTransition.first.first)
 				return true;
+			for(const automaton::State& target : localTransition.second) {
+				if(target == state)
+					return true;
+			}
 		}
-	}
-
-	return false;
-}
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::InitialStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::InitialStates >::available ( const automaton::State & state ) const {
-	const automaton::VisiblyPushdownNPDA * automaton = static_cast < const automaton::VisiblyPushdownNPDA * > ( this );
+class ComponentConstraint2< automaton::VisiblyPushdownNPDA, automaton::State, automaton::InitialStates > {
+public:
+	static bool used ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::VisiblyPushdownNPDA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::VisiblyPushdownNPDA::Component < automaton::VisiblyPushdownNPDA, automaton::State, automaton::InitialStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::VisiblyPushdownNPDA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
index 35f85831287a30615cb1adfaa8f2fc4b327d993f..1ba58d8b780683b079742853133440dca4665302 100644
--- a/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
+++ b/alib2data/src/automaton/PDA/VisiblyPushdownNPDA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include <vector>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -30,7 +30,7 @@ class InitialStates;
  * Represents Finite Automaton.
  * Can store nondeterministic finite automaton without epsilon transitions.
  */
-class VisiblyPushdownNPDA : public AutomatonBase, public std::Components < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class VisiblyPushdownNPDA : public AutomatonBase, public std::Components2 < VisiblyPushdownNPDA, alphabet::Symbol, std::tuple < CallAlphabet, ReturnAlphabet, LocalAlphabet, PushdownStoreAlphabet >, std::tuple < BottomOfTheStackSymbol >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, std::set < std::pair < State, alphabet::Symbol > > > callTransitions;
 	std::map < std::tuple < State, alphabet::Symbol, alphabet::Symbol >, std::set < State > > returnTransitions;