diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.cpp b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
index 1f9f5c85d4f93fe2401f4168e3d4eadce14f949e..3da8e8985c54898798efcb2a7d73f505b64fcf7a 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.cpp
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
@@ -24,7 +24,7 @@
 
 namespace automaton {
 
-EpsilonNFA::EpsilonNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+EpsilonNFA::EpsilonNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components2 < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 EpsilonNFA::EpsilonNFA ( State initialState ) : EpsilonNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
@@ -315,77 +315,74 @@ void EpsilonNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
 namespace std {
 
 template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::EpsilonNFA * automaton = static_cast < const automaton::EpsilonNFA * > ( this );
-
-	for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton->getTransitions ( ) )
-		if ( transition.first.second.is < alphabet::Symbol > ( ) && ( transition.first.second.get < alphabet::Symbol > ( ) == symbol ) )
-			return true;
-
-	return false;
-}
+class ComponentConstraint2< automaton::EpsilonNFA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::EpsilonNFA & automaton, const alphabet::Symbol & symbol ) {
+		for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+			if ( transition.first.second.is < alphabet::Symbol > ( ) && ( transition.first.second.get < alphabet::Symbol > ( ) == symbol ) )
+				return true;
+
+		return false;
+	}
 
-template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+	static bool available ( const automaton::EpsilonNFA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-template < >
-void automaton::EpsilonNFA::Component < automaton::EpsilonNFA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+	static void valid ( const automaton::EpsilonNFA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::EpsilonNFA * automaton = static_cast < const automaton::EpsilonNFA * > ( this );
-
-	if ( automaton->getInitialState ( ) == state )
-		return true;
-
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+class ComponentConstraint2< automaton::EpsilonNFA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-	for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton->getTransitions ( ) )
-		if ( ( transition.first.first == state ) || transition.second.count ( state ) )
+		if ( automaton.getFinalStates ( ).count ( state ) )
 			return true;
 
-	return false;
-}
+		for ( const std::pair < const std::pair < automaton::State, std::variant < ::string::Epsilon, alphabet::Symbol > >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+			if ( ( transition.first.first == state ) || transition.second.count ( state ) )
+				return true;
 
-template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		return false;
+	}
 
-template < >
-void automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static bool available ( const automaton::EpsilonNFA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::EpsilonNFA * automaton = static_cast < const automaton::EpsilonNFA * > ( this );
+class ComponentConstraint2< automaton::EpsilonNFA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::EpsilonNFA &, const automaton::State & ) {
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::EpsilonNFA::Component < automaton::EpsilonNFA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::EpsilonNFA::Element < automaton::EpsilonNFA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::EpsilonNFA * automaton = static_cast < const automaton::EpsilonNFA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::EpsilonNFA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::EpsilonNFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::EpsilonNFA::Element < automaton::EpsilonNFA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::EpsilonNFA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.h b/alib2data/src/automaton/FSM/EpsilonNFA.h
index 209a9e7e83ecb8d9a700a4e3a4b2a28a56924ef2..4fa7c5e91077d6c332af90fc33bb064b3fa38367 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.h
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.h
@@ -10,7 +10,7 @@
 
 #include <map>
 #include <variant>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../../alphabet/Symbol.h"
 #include "../../string/Epsilon.h"
@@ -29,7 +29,7 @@ class States;
 class FinalStates;
 class InitialState;
 
-class EpsilonNFA : public AutomatonBase, public std::Components < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class EpsilonNFA : public AutomatonBase, public std::Components2 < EpsilonNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitions;
 
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.cpp b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
index b6336f904a50bb1f4f74b73990f07ec090b0f88a..a0acd6a0874eef16424f11dc242784be92a3d887 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.cpp
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
@@ -28,7 +28,7 @@
 
 namespace automaton {
 
-ExtendedNFA::ExtendedNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+ExtendedNFA::ExtendedNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components2 < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 ExtendedNFA::ExtendedNFA ( State initialState ) : ExtendedNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
@@ -228,77 +228,74 @@ void ExtendedNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
 namespace std {
 
 template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::ExtendedNFA * automaton = static_cast < const automaton::ExtendedNFA * > ( this );
+class ComponentConstraint2< automaton::ExtendedNFA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::ExtendedNFA & automaton, const alphabet::Symbol & symbol ) {
+		for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+			if ( transition.first.second.getAlphabet ( ).count ( symbol ) == 1 )
+				return true;
+
+		return false;
+	}
 
-	for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton->getTransitions ( ) )
-		if ( transition.first.second.getAlphabet ( ).count ( symbol ) == 1 )
-			return true;
+	static bool available ( const automaton::ExtendedNFA &, const alphabet::Symbol & ) {
+		return true;
+	}
 
-	return false;
-}
+	static void valid ( const automaton::ExtendedNFA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
+class ComponentConstraint2< automaton::ExtendedNFA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
+			return true;
 
-template < >
-void automaton::ExtendedNFA::Component < automaton::ExtendedNFA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
+		if ( automaton.getFinalStates ( ).count ( state ) )
+			return true;
 
-template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::ExtendedNFA * automaton = static_cast < const automaton::ExtendedNFA * > ( this );
+		for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton.getTransitions ( ) )
+			if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
+				return true;
 
-	if ( automaton->getInitialState ( ) == state )
-		return true;
+		return false;
+	}
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
+	static bool available ( const automaton::ExtendedNFA &, const automaton::State & ) {
 		return true;
+	}
 
-	for ( const std::pair < const std::pair < automaton::State, regexp::RegExp >, std::set < automaton::State > > & transition : automaton->getTransitions ( ) )
-		if ( ( transition.first.first == state ) || ( transition.second.find ( state ) != transition.second.end ( ) ) )
-			return true;
-
-	return false;
-}
-
-template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
-
-template < >
-void automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
+class ComponentConstraint2< automaton::ExtendedNFA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::ExtendedNFA &, const automaton::State & ) {
 	return false;
 }
 
-template < >
-bool automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::ExtendedNFA * automaton = static_cast < const automaton::ExtendedNFA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::ExtendedNFA::Component < automaton::ExtendedNFA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::ExtendedNFA::Element < automaton::ExtendedNFA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::ExtendedNFA * automaton = static_cast < const automaton::ExtendedNFA * > ( this );
-
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+class ElementConstraint2< automaton::ExtendedNFA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::ExtendedNFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
 
-template < >
-void automaton::ExtendedNFA::Element < automaton::ExtendedNFA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::ExtendedNFA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.h b/alib2data/src/automaton/FSM/ExtendedNFA.h
index c24c86d9caef978dffe060557e69c4b788f5ca55..8503db403c141b687d4c25a26f5cfb055f737443 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.h
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.h
@@ -30,7 +30,7 @@ class States;
 class FinalStates;
 class InitialState;
 
-class ExtendedNFA : public AutomatonBase, public std::Components < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class ExtendedNFA : public AutomatonBase, public std::Components2 < ExtendedNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitions;
 
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
index aa5fd2db152f2cb54743e96e2b2ce9898f337d57..c6df9881c01f756b0eb18b2357973524502b63f8 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
@@ -22,7 +22,7 @@
 
 namespace automaton {
 
-MultiInitialStateNFA::MultiInitialStateNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < State > initialStates, std::set < State > finalStates ) : std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
+MultiInitialStateNFA::MultiInitialStateNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, std::set < State > initialStates, std::set < State > finalStates ) : std::Components2 < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( initialStates ), std::move ( finalStates ) ), std::tuple < > ( ) ) {
 }
 
 MultiInitialStateNFA::MultiInitialStateNFA ( ) : MultiInitialStateNFA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < State > { }, std::set < State > { } ) {
@@ -208,82 +208,78 @@ void MultiInitialStateNFA::composeTransitions ( std::deque < sax::Token > & out
 namespace std {
 
 template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::MultiInitialStateNFA * automaton = static_cast < const automaton::MultiInitialStateNFA * > ( this );
+class ComponentConstraint2< automaton::MultiInitialStateNFA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::MultiInitialStateNFA & 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;
 
-	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::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::MultiInitialStateNFA * automaton = static_cast < const automaton::MultiInitialStateNFA * > ( this );
-
-	if ( automaton->getInitialStates ( ).count ( state ) )
-		return true;
+		return false;
+	}
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
+	static bool available ( const automaton::MultiInitialStateNFA &, const alphabet::Symbol & ) {
 		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 ( ) ) )
-			return true;
-
-	return false;
-}
+	static void valid ( const automaton::MultiInitialStateNFA &, const alphabet::Symbol & ) {
+	}
+};
 
 template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+class ComponentConstraint2< automaton::MultiInitialStateNFA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::MultiInitialStateNFA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialStates ( ).count ( state ) )
+			return true;
 
-template < >
-void automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+		if ( automaton.getFinalStates ( ).count ( state ) )
+			return true;
 
-template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	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::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::MultiInitialStateNFA * automaton = static_cast < const automaton::MultiInitialStateNFA * > ( this );
+		return false;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static bool available ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+		return true;
+	}
 
-template < >
-void automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+	static void valid ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::InitialStates >::used ( const automaton::State & ) const {
-	return false;
-}
+class ComponentConstraint2< automaton::MultiInitialStateNFA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-bool automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::InitialStates >::available ( const automaton::State & state ) const {
-	const automaton::MultiInitialStateNFA * automaton = static_cast < const automaton::MultiInitialStateNFA * > ( this );
+	static bool available ( const automaton::MultiInitialStateNFA & 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::MultiInitialStateNFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNFA, automaton::State, automaton::InitialStates >::valid ( const automaton::State & ) const {
-}
+class ComponentConstraint2< automaton::MultiInitialStateNFA, automaton::State, automaton::InitialStates > {
+public:
+	static bool used ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+		return false;
+	}
+
+	static bool available ( const automaton::MultiInitialStateNFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
+
+	static void valid ( const automaton::MultiInitialStateNFA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
index b40a32f4508a7de145124e986ccc7f4059aa53e4..c252e15b1aa684df66e49f8f45b68db3d2e9e4bb 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.h
@@ -9,7 +9,7 @@
 #define MULTI_INITIAL_STATE_NFA_H_
 
 #include <map>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -27,7 +27,7 @@ class States;
 class FinalStates;
 class InitialStates;
 
-class MultiInitialStateNFA : public AutomatonBase, public std::Components < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
+class MultiInitialStateNFA : public AutomatonBase, public std::Components2 < MultiInitialStateNFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, InitialStates, FinalStates >, std::tuple < > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;
 
diff --git a/alib2data/src/automaton/FSM/NFA.cpp b/alib2data/src/automaton/FSM/NFA.cpp
index 701ff3016f0bd8967fca472e18aa90889890c32b..5daa3d7eb88596e05224d8517ed5cde139ca5350 100644
--- a/alib2data/src/automaton/FSM/NFA.cpp
+++ b/alib2data/src/automaton/FSM/NFA.cpp
@@ -20,7 +20,7 @@
 
 namespace automaton {
 
-NFA::NFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
+NFA::NFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components2 < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ) ), std::make_tuple ( std::move ( initialState ) ) ) {
 }
 
 NFA::NFA ( State initialState ) : NFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
@@ -200,77 +200,74 @@ void NFA::composeTransitions ( std::deque < sax::Token > & out ) const {
 namespace std {
 
 template < >
-bool automaton::NFA::Component < automaton::NFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
-	const automaton::NFA * automaton = static_cast < const automaton::NFA * > ( this );
+class ComponentConstraint2< automaton::NFA, alphabet::Symbol, automaton::InputAlphabet > {
+public:
+	static bool used ( const automaton::NFA & 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;
 
-	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::NFA::Component < automaton::NFA, alphabet::Symbol, automaton::InputAlphabet >::available ( const alphabet::Symbol & ) const {
-	return true;
-}
-
-template < >
-void automaton::NFA::Component < automaton::NFA, alphabet::Symbol, automaton::InputAlphabet >::valid ( const alphabet::Symbol & ) const {
-}
-
-template < >
-bool automaton::NFA::Component < automaton::NFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
-	const automaton::NFA * automaton = static_cast < const automaton::NFA * > ( this );
+		return false;
+	}
 
-	if ( automaton->getInitialState ( ) == state )
+	static bool available ( const automaton::NFA &, const alphabet::Symbol & ) {
 		return true;
+	}
 
-	if ( automaton->getFinalStates ( ).count ( state ) )
-		return true;
+	static void valid ( const automaton::NFA &, const alphabet::Symbol & ) {
+	}
+};
 
-	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 ( ) ) )
+template < >
+class ComponentConstraint2< automaton::NFA, automaton::State, automaton::States > {
+public:
+	static bool used ( const automaton::NFA & automaton, const automaton::State & state ) {
+		if ( automaton.getInitialState ( ) == state )
 			return true;
 
-	return false;
-}
-
-template < >
-bool automaton::NFA::Component < automaton::NFA, automaton::State, automaton::States >::available ( const automaton::State & ) const {
-	return true;
-}
+		if ( automaton.getFinalStates ( ).count ( state ) )
+			return true;
 
-template < >
-void automaton::NFA::Component < automaton::NFA, automaton::State, automaton::States >::valid ( const automaton::State & ) const {
-}
+		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::NFA::Component < automaton::NFA, automaton::State, automaton::FinalStates >::used ( const automaton::State & ) const {
-	return false;
-}
+		return false;
+	}
 
-template < >
-bool automaton::NFA::Component < automaton::NFA, automaton::State, automaton::FinalStates >::available ( const automaton::State & state ) const {
-	const automaton::NFA * automaton = static_cast < const automaton::NFA * > ( this );
+	static bool available ( const automaton::NFA &, const automaton::State & ) {
+		return true;
+	}
 
-	return automaton->accessComponent < automaton::States > ( ).get ( ).count ( state );
-}
+	static void valid ( const automaton::NFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::NFA::Component < automaton::NFA, automaton::State, automaton::FinalStates >::valid ( const automaton::State & ) const {
-}
+class ComponentConstraint2< automaton::NFA, automaton::State, automaton::FinalStates > {
+public:
+	static bool used ( const automaton::NFA &, const automaton::State & ) {
+		return false;
+	}
 
-template < >
-bool automaton::NFA::Element < automaton::NFA, automaton::State, automaton::InitialState >::available ( const automaton::State & state ) const {
-	const automaton::NFA * automaton = static_cast < const automaton::NFA * > ( this );
+	static bool available ( const automaton::NFA & 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::NFA &, const automaton::State & ) {
+	}
+};
 
 template < >
-void automaton::NFA::Element < automaton::NFA, automaton::State, automaton::InitialState >::valid ( const automaton::State & ) const {
-}
+class ElementConstraint2< automaton::NFA, automaton::State, automaton::InitialState > {
+public:
+	static bool available ( const automaton::NFA & automaton, const automaton::State & state ) {
+		return automaton.accessComponent < automaton::States > ( ).get ( ).count ( state );
+	}
+
+	static void valid ( const automaton::NFA &, const automaton::State & ) {
+	}
+};
 
 } /* namespace std */
 
diff --git a/alib2data/src/automaton/FSM/NFA.h b/alib2data/src/automaton/FSM/NFA.h
index a4390c741cf2aceafb1b34134b648d4cafd7ff8a..8e9e180af82cc883873a40a2719e725416195533 100644
--- a/alib2data/src/automaton/FSM/NFA.h
+++ b/alib2data/src/automaton/FSM/NFA.h
@@ -9,7 +9,7 @@
 #define NFA_H_
 
 #include <map>
-#include <core/components.hpp>
+#include <core/components2.hpp>
 #include "../AutomatonBase.h"
 #include "../common/State.h"
 #include "../../alphabet/Symbol.h"
@@ -27,7 +27,7 @@ class States;
 class FinalStates;
 class InitialState;
 
-class NFA : public AutomatonBase, public std::Components < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
+class NFA : public AutomatonBase, public std::Components2 < NFA, alphabet::Symbol, std::tuple < InputAlphabet >, std::tuple < >, automaton::State, std::tuple < States, FinalStates >, std::tuple < InitialState > > {
 protected:
 	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitions;