From 1d11713c29d0e750b9db9f5f69897bfefb8b8d06 Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Wed, 27 Jul 2016 14:03:48 +0200
Subject: [PATCH] update remaining FSMs to components2

---
 alib2data/src/automaton/FSM/EpsilonNFA.cpp    | 107 ++++++++--------
 alib2data/src/automaton/FSM/EpsilonNFA.h      |   4 +-
 alib2data/src/automaton/FSM/ExtendedNFA.cpp   | 103 ++++++++--------
 alib2data/src/automaton/FSM/ExtendedNFA.h     |   2 +-
 .../automaton/FSM/MultiInitialStateNFA.cpp    | 116 +++++++++---------
 .../src/automaton/FSM/MultiInitialStateNFA.h  |   4 +-
 alib2data/src/automaton/FSM/NFA.cpp           | 107 ++++++++--------
 alib2data/src/automaton/FSM/NFA.h             |   4 +-
 8 files changed, 217 insertions(+), 230 deletions(-)

diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.cpp b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
index 1f9f5c85d4..3da8e8985c 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 209a9e7e83..4fa7c5e910 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 b6336f904a..a0acd6a087 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 c24c86d9ca..8503db403c 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 aa5fd2db15..c6df9881c0 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 b40a32f450..c252e15b1a 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 701ff3016f..5daa3d7eb8 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 a4390c741c..8e9e180af8 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;
 
-- 
GitLab