diff --git a/alib2data/src/automaton/FSM/CompactNFA.cpp b/alib2data/src/automaton/FSM/CompactNFA.cpp
index d96f3160353eef815a5a425627c89b64a514cf88..49d3c7765fab37ea76bd655b3bcabb4bd304e5cc 100644
--- a/alib2data/src/automaton/FSM/CompactNFA.cpp
+++ b/alib2data/src/automaton/FSM/CompactNFA.cpp
@@ -28,190 +28,191 @@ namespace automaton {
 CompactNFA::CompactNFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < CompactNFA, 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 ) ) ) {
 }
 
-CompactNFA::CompactNFA(State initialState) : CompactNFA( std::set<State> { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set<State> {} ) {
+CompactNFA::CompactNFA ( State initialState ) : CompactNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
 }
 
-CompactNFA::CompactNFA(const EpsilonNFA& other) : CompactNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		if(transition.first.second.is<string::Epsilon>()) {
-			std::pair<State, string::LinearString> key = std::make_pair(transition.first.first, string::LinearString( std::vector<alphabet::Symbol> { } ));
+CompactNFA::CompactNFA ( const EpsilonNFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		if ( transition.first.second.is < string::Epsilon > ( ) ) {
+			std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { } ) );
 			transitions[key] = transition.second;
 		} else {
-			std::pair<State, string::LinearString> key = std::make_pair(transition.first.first, string::LinearString( std::vector<alphabet::Symbol> { transition.first.second.get<alphabet::Symbol>() } ));
+			std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second.get < alphabet::Symbol > ( ) } ) );
 			transitions[key] = transition.second;
 		}
 	}
 }
 
-CompactNFA::CompactNFA(const MultiInitialStateNFA& other) : CompactNFA( other.getStates() + std::set < State > { automaton::createUniqueState(automaton::State("q0"), other.getStates()) }, other.getInputAlphabet(), automaton::createUniqueState(automaton::State("q0"), other.getStates()), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, string::LinearString> key = std::make_pair(transition.first.first, string::LinearString( std::vector<alphabet::Symbol> { transition.first.second} ));
+CompactNFA::CompactNFA ( const MultiInitialStateNFA & other ) : CompactNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
 		transitions[key] = transition.second;
 	}
-	std::pair<State, string::LinearString> key = std::make_pair(this->getInitialState(), string::LinearString(std::vector<alphabet::Symbol> {}));
-	transitions[key] = other.getInitialStates();
+
+	std::pair < State, string::LinearString > key = std::make_pair ( this->getInitialState ( ), string::LinearString ( std::vector < alphabet::Symbol > { } ) );
+	transitions[key] = other.getInitialStates ( );
 }
 
-CompactNFA::CompactNFA(const NFA& other) : CompactNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, string::LinearString> key = std::make_pair(transition.first.first, string::LinearString( std::vector<alphabet::Symbol> { transition.first.second} ));
+CompactNFA::CompactNFA ( const NFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
 		transitions[key] = transition.second;
 	}
 }
 
-CompactNFA::CompactNFA(const DFA& other) : CompactNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, string::LinearString> key = std::make_pair(transition.first.first, string::LinearString( std::vector<alphabet::Symbol> { transition.first.second} ));
-		transitions[key].insert(transition.second);
+CompactNFA::CompactNFA ( const DFA & other ) : CompactNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, string::LinearString > key = std::make_pair ( transition.first.first, string::LinearString ( std::vector < alphabet::Symbol > { transition.first.second } ) );
+		transitions[key].insert ( transition.second );
 	}
 }
 
-AutomatonBase* CompactNFA::clone() const {
-	return new CompactNFA(*this);
+AutomatonBase * CompactNFA::clone ( ) const {
+	return new CompactNFA ( * this );
 }
 
-AutomatonBase* CompactNFA::plunder() && {
-	return new CompactNFA(std::move(*this));
+AutomatonBase * CompactNFA::plunder ( ) && {
+	return new CompactNFA ( std::move ( * this ) );
 }
 
-bool CompactNFA::addTransition(State from, string::LinearString input, State to) {
-	if (!getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool CompactNFA::addTransition ( State from, string::LinearString input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	const std::set<alphabet::Symbol>& inputStringAlphabet = input.getAlphabet();
+	const std::set < alphabet::Symbol > & inputStringAlphabet = input.getAlphabet ( );
 
-	// Transition regexp's alphabet must be subset of automaton's alphabet
-	if (! std::includes(getInputAlphabet().begin(), getInputAlphabet().end(), inputStringAlphabet.begin(), inputStringAlphabet.end()))
-		throw AutomatonException("Input string is over different alphabet than automaton");
+	 // Transition regexp's alphabet must be subset of automaton's alphabet
+	if ( !std::includes ( getInputAlphabet ( ).begin ( ), getInputAlphabet ( ).end ( ), inputStringAlphabet.begin ( ), inputStringAlphabet.end ( ) ) )
+		throw AutomatonException ( "Input string is over different alphabet than automaton" );
 
-	if (!getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, string::LinearString> key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, string::LinearString > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	return transitions[std::move(key)].insert(std::move(to)).second;
+	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool CompactNFA::removeTransition(const State& from, const string::LinearString& input, const State& to) {
-	std::pair<State, string::LinearString> key = std::make_pair(from, input);
+bool CompactNFA::removeTransition ( const State & from, const string::LinearString & input, const State & to ) {
+	std::pair < State, string::LinearString > key = std::make_pair ( from, input );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-const std::map<std::pair<State, string::LinearString>, std::set<State>>& CompactNFA::getTransitions() const {
+const std::map < std::pair < State, string::LinearString >, std::set < State > > & CompactNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<std::pair<State, string::LinearString>, std::set<State>> CompactNFA::getTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, string::LinearString >, std::set < State > > CompactNFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, string::LinearString>, std::set<State>> transitionsFromState;
-	for (const std::pair<const std::pair<State, string::LinearString>, std::set<State>>& transition : transitions) {
-		if (transition.first.first == from) {
-			transitionsFromState.insert(make_pair(transition.first, transition.second));
-		}
-	}
+	std::map < std::pair < State, string::LinearString >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, string::LinearString >, std::set < State > > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, string::LinearString>, std::set<State>> CompactNFA::getTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, string::LinearString >, std::set < State > > CompactNFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, string::LinearString>, std::set<State>> transitionsToState;
-	for (const std::pair<const std::pair<State, string::LinearString>, std::set<State>>& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end()) {
-			transitionsToState.insert(make_pair(transition.first, transition.second));
-		}
-	}
+	std::map < std::pair < State, string::LinearString >, std::set < State > > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, string::LinearString >, std::set < State > > & transition : transitions )
+		if ( transition.second.find ( to ) != transition.second.end ( ) )
+			transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsToState;
 }
 
-int CompactNFA::compare(const CompactNFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialState(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates(), other.getTransitions());
+int CompactNFA::compare ( const CompactNFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialState ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ), other.getTransitions ( ) );
+
+	std::compare < decltype ( first ) > comp;
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	return comp ( first, second );
 }
 
-void CompactNFA::operator>>(std::ostream& out) const {
+void CompactNFA::operator >>( std::ostream & out ) const {
 	out << "(CompactNFA "
-		<< "states = " << getStates()
-		<< "inputAlphabet = " << getInputAlphabet()
-		<< "initialState = " << getInitialState()
-		<< "finalStates = " << getFinalStates()
-		<< "transitions = " << transitions
-		<< ")";
+	    << "states = " << getStates ( )
+	    << "inputAlphabet = " << getInputAlphabet ( )
+	    << "initialState = " << getInitialState ( )
+	    << "finalStates = " << getFinalStates ( )
+	    << "transitions = " << transitions
+	    << ")";
 }
 
-CompactNFA::operator std::string () const {
+CompactNFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string CompactNFA::XML_TAG_NAME = "CompactNFA";
 
-CompactNFA CompactNFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, CompactNFA::XML_TAG_NAME);
+CompactNFA CompactNFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, CompactNFA::XML_TAG_NAME );
+
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	CompactNFA automaton ( std::move ( initialState ) );
 
-	CompactNFA automaton(std::move(initialState));
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setFinalStates(std::move(finalStates));
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
 
-	AutomatonFromXMLParser::parseTransitions<CompactNFA>(input, automaton);
+	AutomatonFromXMLParser::parseTransitions < CompactNFA > ( input, automaton );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, CompactNFA::XML_TAG_NAME);
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, CompactNFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void CompactNFA::parseTransition(std::deque<sax::Token>::iterator& input, CompactNFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	string::LinearString inputString = AutomatonFromXMLParser::parseTransitionInputString(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void CompactNFA::parseTransition ( std::deque < sax::Token >::iterator & input, CompactNFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	string::LinearString inputString = AutomatonFromXMLParser::parseTransitionInputString ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputString), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputString ), std::move ( to ) );
 }
 
-void CompactNFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(CompactNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void CompactNFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( CompactNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialState(out, this->getInitialState());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialState ( out, this->getInitialState ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(CompactNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( CompactNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void CompactNFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		for(const auto& targetState: transition.second) {
-			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void CompactNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
 
-			AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-			AutomatonToXMLComposer::composeTransitionInputString(out, transition.first.second);
-			AutomatonToXMLComposer::composeTransitionTo(out, targetState);
+	for ( const auto & transition : this->getTransitions ( ) )
+		for ( const auto & targetState : transition.second ) {
+			out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+			AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+			AutomatonToXMLComposer::composeTransitionInputString ( out, transition.first.second );
+			AutomatonToXMLComposer::composeTransitionTo ( out, targetState );
+
+			out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 		}
-	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -222,8 +223,8 @@ template < >
 bool automaton::CompactNFA::Component < automaton::CompactNFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
 	const automaton::CompactNFA * automaton = static_cast < const automaton::CompactNFA * > ( this );
 
-	for (const std::pair<const std::pair<automaton::State, ::string::LinearString>, std::set<automaton::State> >& transition : automaton->getTransitions())
-		if (transition.first.second.getAlphabet().count(symbol))
+	for ( const std::pair < const std::pair < automaton::State, ::string::LinearString >, std::set < automaton::State > > & transition : automaton->getTransitions ( ) )
+		if ( transition.first.second.getAlphabet ( ).count ( symbol ) )
 			return true;
 
 	return false;
@@ -242,14 +243,14 @@ template < >
 bool automaton::CompactNFA::Component < automaton::CompactNFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
 	const automaton::CompactNFA * automaton = static_cast < const automaton::CompactNFA * > ( this );
 
-	if (automaton->getInitialState() == state)
+	if ( automaton->getInitialState ( ) == state )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( state ) )
 		return true;
 
-	for (const std::pair<const std::pair<automaton::State, ::string::LinearString>, std::set<automaton::State> >& t : automaton->getTransitions())
-		if (t.first.first == state || t.second.count(state))
+	for ( const std::pair < const std::pair < automaton::State, ::string::LinearString >, std::set < automaton::State > > & t : automaton->getTransitions ( ) )
+		if ( ( t.first.first == state ) || t.second.count ( state ) )
 			return true;
 
 	return false;
@@ -295,13 +296,13 @@ void automaton::CompactNFA::Element < automaton::CompactNFA, automaton::State, a
 
 namespace alib {
 
-auto compactNFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::CompactNFA>();
-auto compactNFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::CompactNFA>();
+auto compactNFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::CompactNFA > ( );
+auto compactNFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::CompactNFA > ( );
 
-auto CompactNFAFromDFA = castApi::CastRegister<automaton::CompactNFA, automaton::DFA>();
-auto CompactNFAFromNFA = castApi::CastRegister<automaton::CompactNFA, automaton::NFA>();
-auto CompactNFAFromMultiInitialStateNFA = castApi::CastRegister<automaton::CompactNFA, automaton::MultiInitialStateNFA>();
-auto CompactNFAEpsilonNFA = castApi::CastRegister<automaton::CompactNFA, automaton::EpsilonNFA>();
-auto CompactNFACastBinder = castApi::CastPoolStringBinder<automaton::CompactNFA>(automaton::CompactNFA::XML_TAG_NAME);
+auto CompactNFAFromDFA = castApi::CastRegister < automaton::CompactNFA, automaton::DFA > ( );
+auto CompactNFAFromNFA = castApi::CastRegister < automaton::CompactNFA, automaton::NFA > ( );
+auto CompactNFAFromMultiInitialStateNFA = castApi::CastRegister < automaton::CompactNFA, automaton::MultiInitialStateNFA > ( );
+auto CompactNFAEpsilonNFA = castApi::CastRegister < automaton::CompactNFA, automaton::EpsilonNFA > ( );
+auto CompactNFACastBinder = castApi::CastPoolStringBinder < automaton::CompactNFA > ( automaton::CompactNFA::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/automaton/FSM/DFA.cpp b/alib2data/src/automaton/FSM/DFA.cpp
index f0573fdd8578cdd850fe697357ae5fd2a30727f5..eec791c23896f350f59f0e8685a51468293acf96 100644
--- a/alib2data/src/automaton/FSM/DFA.cpp
+++ b/alib2data/src/automaton/FSM/DFA.cpp
@@ -22,173 +22,170 @@ namespace automaton {
 DFA::DFA ( std::set < State > states, std::set < alphabet::Symbol > inputAlphabet, State initialState, std::set < State > finalStates ) : std::Components < DFA, 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 ) ) ) {
 }
 
-DFA::DFA(State initialState) : DFA( std::set<State> { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set<State> {} ) {
+DFA::DFA ( State initialState ) : DFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
 }
 
-AutomatonBase* DFA::clone() const {
-	return new DFA(*this);
+AutomatonBase * DFA::clone ( ) const {
+	return new DFA ( * this );
 }
 
-AutomatonBase* DFA::plunder() && {
-	return new DFA(std::move(*this));
+AutomatonBase * DFA::plunder ( ) && {
+	return new DFA ( std::move ( * this ) );
 }
 
-bool DFA::addTransition(State from, alphabet::Symbol input, State to) {
-	if (!getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool DFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	if (!getInputAlphabet().count(input))
-		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
+	if ( !getInputAlphabet ( ).count ( input ) )
+		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
-	if (!getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	if (transitions.find(key) != transitions.end()) {
-		if(transitions.find(key)->second == to)
+	if ( transitions.find ( key ) != transitions.end ( ) ) {
+		if ( transitions.find ( key )->second == to )
 			return false;
 		else
-			throw AutomatonException(
-				"Transition from this state and symbol already exists (\"" + (std::string) key.first.getName() + "\", \"" + (std::string) key.second + "\") -> \"" + (std::string) to.getName()
-						+ "\".");
+			throw AutomatonException ( "Transition from this state and symbol already exists (\"" + ( std::string ) key.first.getName ( ) + "\", \"" + ( std::string ) key.second + "\") -> \"" + ( std::string ) to.getName ( ) + "\"." );
 	}
 
-	transitions.insert(std::make_pair(std::move(key), std::move(to)));
+	transitions.insert ( std::make_pair ( std::move ( key ), std::move ( to ) ) );
 	return true;
 }
 
-bool DFA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool DFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
 
-	if (transitions.find(key) == transitions.end())
+	if ( transitions.find ( key ) == transitions.end ( ) )
 		return false;
 
-	if(transitions.find(key)->second != to)
-		throw AutomatonException(
-				"Transition (\"" + (std::string) from.getName() + "\", \"" + (std::string) input
-						+ "\") -> \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( transitions.find ( key )->second != to )
+		throw AutomatonException ( "Transition (\"" + ( std::string ) from.getName ( ) + "\", \"" + ( std::string ) input + "\") -> \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	transitions.erase(key);
+	transitions.erase ( key );
 	return true;
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, State>& DFA::getTransitions() const {
+const std::map < std::pair < State, alphabet::Symbol >, State > & DFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, State> DFA::getTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, State > DFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, State> transitionsFromState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, State>& transition : transitions) {
-		if (transition.first.first == from) {
-			transitionsFromState.insert(transition);
-		}
-	}
+	std::map < std::pair < State, alphabet::Symbol >, State > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, State > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState.insert ( transition );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, State> DFA::getTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, State > DFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, State> transitionsToState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, State>& transition : transitions) {
-		if (transition.second == to) {
-			transitionsToState.insert(transition);
-		}
-	}
+	std::map < std::pair < State, alphabet::Symbol >, State > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, State > & transition : transitions )
+		if ( transition.second == to )
+			transitionsToState.insert ( transition );
 
 	return transitionsToState;
 }
 
-bool DFA::isTotal() const {
-	return transitions.size() == getInputAlphabet().size() * getStates().size();
+bool DFA::isTotal ( ) const {
+	return transitions.size ( ) == getInputAlphabet ( ).size ( ) * getStates ( ).size ( );
 }
 
-int DFA::compare(const DFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialState(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates(), other.transitions);
+int DFA::compare ( const DFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialState ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ), other.transitions );
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
 }
 
-void DFA::operator>>(std::ostream& out) const {
+void DFA::operator >>( std::ostream & out ) const {
 	out << "(DFA "
-		<< " states = " << getStates()
-		<< " inputAlphabet = " << getInputAlphabet()
-		<< " initialState = " << getInitialState()
-		<< " finalStates = " << getFinalStates()
-		<< " transitions = " << transitions
-		<< ")";
+	    << " states = " << getStates ( )
+	    << " inputAlphabet = " << getInputAlphabet ( )
+	    << " initialState = " << getInitialState ( )
+	    << " finalStates = " << getFinalStates ( )
+	    << " transitions = " << transitions
+	    << ")";
 }
 
-DFA::operator std::string () const {
+DFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string DFA::XML_TAG_NAME = "DFA";
 
-DFA DFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, DFA::XML_TAG_NAME);
+DFA DFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, DFA::XML_TAG_NAME );
+
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	DFA automaton ( std::move ( initialState ) );
 
-	DFA automaton(std::move(initialState));
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setFinalStates(std::move(finalStates));
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
 
-	AutomatonFromXMLParser::parseTransitions<DFA>(input, automaton);
+	AutomatonFromXMLParser::parseTransitions < DFA > ( input, automaton );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, DFA::XML_TAG_NAME);
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, DFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void DFA::parseTransition(std::deque<sax::Token>::iterator& input, DFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void DFA::parseTransition ( std::deque < sax::Token >::iterator & input, DFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
 }
 
-void DFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(DFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void DFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( DFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialState(out, this->getInitialState());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialState ( out, this->getInitialState ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(DFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( DFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void DFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void DFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const auto & transition : this->getTransitions ( ) ) {
+		out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-		AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-		AutomatonToXMLComposer::composeTransitionInputSymbol(out, transition.first.second);
-		AutomatonToXMLComposer::composeTransitionTo(out, transition.second);
+		AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+		AutomatonToXMLComposer::composeTransitionInputSymbol ( out, transition.first.second );
+		AutomatonToXMLComposer::composeTransitionTo ( out, transition.second );
 
-		out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+		out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -199,8 +196,8 @@ template < >
 bool automaton::DFA::Component < automaton::DFA, alphabet::Symbol, automaton::InputAlphabet >::used ( const alphabet::Symbol & symbol ) const {
 	const automaton::DFA * automaton = static_cast < const automaton::DFA * > ( this );
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, automaton::State>& transition : automaton->getTransitions())
-		if (transition.first.second == symbol)
+	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;
@@ -219,14 +216,14 @@ template < >
 bool automaton::DFA::Component < automaton::DFA, automaton::State, automaton::States >::used ( const automaton::State & state ) const {
 	const automaton::DFA * automaton = static_cast < const automaton::DFA * > ( this );
 
-	if (automaton->getInitialState() == state)
+	if ( automaton->getInitialState ( ) == state )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( 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)
+	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;
 
 	return false;
@@ -272,7 +269,7 @@ void automaton::DFA::Element < automaton::DFA, automaton::State, automaton::Init
 
 namespace alib {
 
-auto DFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::DFA>();
-auto DFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::DFA>();
+auto DFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::DFA > ( );
+auto DFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::DFA > ( );
 
 } /* namespace alib */
diff --git a/alib2data/src/automaton/FSM/EpsilonNFA.cpp b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
index 2883e75db922250a3e099cb47712cd5a4504965b..778d4128827ddd3512a602de441a592a9a12da3d 100644
--- a/alib2data/src/automaton/FSM/EpsilonNFA.cpp
+++ b/alib2data/src/automaton/FSM/EpsilonNFA.cpp
@@ -27,280 +27,289 @@ 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(State initialState) : EpsilonNFA( std::set<State> { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set<State> {} ) {
+EpsilonNFA::EpsilonNFA ( State initialState ) : EpsilonNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
 }
 
-EpsilonNFA::EpsilonNFA(const MultiInitialStateNFA& other) : EpsilonNFA( other.getStates() + std::set < State > { automaton::createUniqueState(automaton::State("q0"), other.getStates()) }, other.getInputAlphabet(), automaton::createUniqueState(automaton::State("q0"), other.getStates()), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(transition.first.first, std::variant<string::Epsilon, alphabet::Symbol>(transition.first.second));
+EpsilonNFA::EpsilonNFA ( const MultiInitialStateNFA & other ) : EpsilonNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
 		transitions[key] = transition.second;
 	}
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(this->getInitialState(), std::variant<string::Epsilon, alphabet::Symbol>(string::Epsilon::EPSILON));
-	transitions[key] = other.getInitialStates();
+
+	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( this->getInitialState ( ), std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
+	transitions[key] = other.getInitialStates ( );
 }
 
-EpsilonNFA::EpsilonNFA(const NFA& other) : EpsilonNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(transition.first.first, std::variant<string::Epsilon, alphabet::Symbol>(transition.first.second));
+EpsilonNFA::EpsilonNFA ( const NFA & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
 		transitions[key] = transition.second;
 	}
 }
 
-EpsilonNFA::EpsilonNFA(const DFA& other) : EpsilonNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(transition.first.first, std::variant<string::Epsilon, alphabet::Symbol>(transition.first.second));
-		transitions[key].insert(transition.second);
+EpsilonNFA::EpsilonNFA ( const DFA & other ) : EpsilonNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( transition.first.first, std::variant < string::Epsilon, alphabet::Symbol > ( transition.first.second ) );
+		transitions[key].insert ( transition.second );
 	}
 }
 
-AutomatonBase* EpsilonNFA::clone() const {
-	return new EpsilonNFA(*this);
+AutomatonBase * EpsilonNFA::clone ( ) const {
+	return new EpsilonNFA ( * this );
 }
 
-AutomatonBase* EpsilonNFA::plunder() && {
-	return new EpsilonNFA(std::move(*this));
+AutomatonBase * EpsilonNFA::plunder ( ) && {
+	return new EpsilonNFA ( std::move ( * this ) );
 }
 
-bool EpsilonNFA::addTransition(State from, std::variant<string::Epsilon, alphabet::Symbol> input, State to) {
-	if (! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool EpsilonNFA::addTransition ( State from, std::variant < string::Epsilon, alphabet::Symbol > input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	if (input.is<alphabet::Symbol>() && ! getInputAlphabet().count(input.get<alphabet::Symbol>()))
-		throw AutomatonException("Input symbol \"" + (std::string) input.get<alphabet::Symbol>() + "\" doesn't exist.");
+	if ( input.is < alphabet::Symbol > ( ) && !getInputAlphabet ( ).count ( input.get < alphabet::Symbol > ( ) ) )
+		throw AutomatonException ( "Input symbol \"" + ( std::string ) input.get < alphabet::Symbol > ( ) + "\" doesn't exist." );
 
-	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	return transitions[std::move(key)].insert(std::move(to)).second;
+	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool EpsilonNFA::addTransition(State from, alphabet::Symbol input, State to) {
-	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(std::move(input));
-	return addTransition(std::move(from), std::move(inputVariant), std::move(to));
+bool EpsilonNFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( std::move ( input ) );
+
+	return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
 }
 
-bool EpsilonNFA::addTransition(State from, State to) {
-	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
-	return addTransition(std::move(from), std::move(inputVariant), std::move(to));
+bool EpsilonNFA::addTransition ( State from, State to ) {
+	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( string::Epsilon::EPSILON );
+
+	return addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
 }
 
-bool EpsilonNFA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(input);
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(from, inputVariant);
+bool EpsilonNFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
+	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( input );
+	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-bool EpsilonNFA::removeTransition(const State& from, const State& to) {
-	std::variant<string::Epsilon, alphabet::Symbol> inputVariant(string::Epsilon::EPSILON);
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key = std::make_pair(from, inputVariant);
+bool EpsilonNFA::removeTransition ( const State & from, const State & to ) {
+	std::variant < string::Epsilon, alphabet::Symbol > inputVariant ( string::Epsilon::EPSILON );
+	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key = std::make_pair ( from, inputVariant );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-const std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& EpsilonNFA::getTransitions() const {
+const std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & EpsilonNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<State, std::set<State> > EpsilonNFA::getEpsilonTransitions() const {
-	std::map<State, std::set<State> > result;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.first.second.is<string::Epsilon>())
-			result[transition.first.first].insert(transition.second.begin(), transition.second.end());
-	}
+std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitions ( ) const {
+	std::map < State, std::set < State > > result;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.first.second.is < string::Epsilon > ( ) )
+			result[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
+
 	return result;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > EpsilonNFA::getSymbolTransitions() const {
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > result;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.first.second.is<alphabet::Symbol>())
-			result[std::pair<State, alphabet::Symbol>(transition.first.first, transition.first.second.get<alphabet::Symbol>())].insert(transition.second.begin(), transition.second.end());
-	}
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitions ( ) const {
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > result;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.first.second.is < alphabet::Symbol > ( ) )
+			result[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
+
 	return result;
 }
 
-std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> > EpsilonNFA::getTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > EpsilonNFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> > transitionsFromState;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.first.first == from)
-			transitionsFromState[transition.first].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map<State, std::set<State> > EpsilonNFA::getEpsilonTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
+
+	std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > > key ( from, std::variant < string::Epsilon, alphabet::Symbol > ( string::Epsilon::EPSILON ) );
+	std::map < State, std::set < State > > res;
+	auto transition = transitions.find ( key );
+
+	if ( transition != transitions.end ( ) )
+		res.insert ( std::make_pair ( from, transition->second ) );
 
-	std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> > key(from, std::variant<string::Epsilon, alphabet::Symbol>(string::Epsilon::EPSILON));
-	std::map<State, std::set<State>> res;
-	auto transition = transitions.find(key);
-	if(transition != transitions.end())
-		res.insert(std::make_pair(from, transition->second));
 	return res;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > EpsilonNFA::getSymbolTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsFromState;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.first.first == from && transition.first.second.is<alphabet::Symbol>())
-			transitionsFromState[std::pair<State, alphabet::Symbol>(transition.first.first, transition.first.second.get<alphabet::Symbol>())].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( ( transition.first.first == from ) && transition.first.second.is < alphabet::Symbol > ( ) )
+			transitionsFromState[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> > EpsilonNFA::getTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > EpsilonNFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end())
-			transitionsToState[transition.first].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.second.find ( to ) != transition.second.end ( ) )
+			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-std::map<State, std::set<State> > EpsilonNFA::getEpsilonTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < State, std::set < State > > EpsilonNFA::getEpsilonTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<State, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end() && transition.first.second.is<string::Epsilon>())
-			transitionsToState[transition.first.first].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < State, std::set < State > > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.is < string::Epsilon > ( ) )
+			transitionsToState[transition.first.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > EpsilonNFA::getSymbolTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > EpsilonNFA::getSymbolTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end() && transition.first.second.is<alphabet::Symbol>())
-			transitionsToState[std::pair<State, alphabet::Symbol>(transition.first.first, transition.first.second.get<alphabet::Symbol>())].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( ( transition.second.find ( to ) != transition.second.end ( ) ) && transition.first.second.is < alphabet::Symbol > ( ) )
+			transitionsToState[std::pair < State, alphabet::Symbol > ( transition.first.first, transition.first.second.get < alphabet::Symbol > ( ) )].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-bool EpsilonNFA::isEpsilonFree() const {
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions)
-		if (transition.first.second.is<string::Epsilon>())
+bool EpsilonNFA::isEpsilonFree ( ) const {
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.first.second.is < string::Epsilon > ( ) )
 			return false;
 
 	return true;
 }
 
-bool EpsilonNFA::isDeterministic() const {
-	for (const std::pair<const std::pair<State, std::variant<string::Epsilon, alphabet::Symbol> >, std::set<State> >& transition : transitions)
-		if (transition.second.size() > 1)
+bool EpsilonNFA::isDeterministic ( ) const {
+	for ( const std::pair < const std::pair < State, std::variant < string::Epsilon, alphabet::Symbol > >, std::set < State > > & transition : transitions )
+		if ( transition.second.size ( ) > 1 )
 			return false;
 
-	return isEpsilonFree();
+	return isEpsilonFree ( );
 }
 
-bool EpsilonNFA::isTotal() const {
-	return isDeterministic() && transitions.size() == getInputAlphabet().size() * getStates().size();
+bool EpsilonNFA::isTotal ( ) const {
+	return isDeterministic ( ) && transitions.size ( ) == getInputAlphabet ( ).size ( ) * getStates ( ).size ( );
 }
 
-int EpsilonNFA::compare(const EpsilonNFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialState(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates(), other.getTransitions());
+int EpsilonNFA::compare ( const EpsilonNFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialState ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ), other.getTransitions ( ) );
+
+	std::compare < decltype ( first ) > comp;
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	return comp ( first, second );
 }
 
-void EpsilonNFA::operator>>(std::ostream& out) const {
+void EpsilonNFA::operator >>( std::ostream & out ) const {
 	out << "(EpsilonNFA "
-		<< "states = " << getStates()
-		<< "inputAlphabet = " << getInputAlphabet()
-		<< "initialState = " << getInitialState()
-		<< "finalStates = " << getFinalStates()
-		<< "transitions = " << transitions
-		<< ")";
+	    << "states = " << getStates ( )
+	    << "inputAlphabet = " << getInputAlphabet ( )
+	    << "initialState = " << getInitialState ( )
+	    << "finalStates = " << getFinalStates ( )
+	    << "transitions = " << transitions
+	    << ")";
 }
 
-EpsilonNFA::operator std::string () const {
+EpsilonNFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string EpsilonNFA::XML_TAG_NAME = "EpsilonNFA";
 
-EpsilonNFA EpsilonNFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, EpsilonNFA::XML_TAG_NAME);
+EpsilonNFA EpsilonNFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, EpsilonNFA::XML_TAG_NAME );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
-	EpsilonNFA automaton(std::move(initialState));
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setFinalStates(std::move(finalStates));
+	EpsilonNFA automaton ( std::move ( initialState ) );
 
-	AutomatonFromXMLParser::parseTransitions<EpsilonNFA>(input, automaton);
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, EpsilonNFA::XML_TAG_NAME);
+	AutomatonFromXMLParser::parseTransitions < EpsilonNFA > ( input, automaton );
+
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, EpsilonNFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void EpsilonNFA::parseTransition(std::deque<sax::Token>::iterator& input, EpsilonNFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	std::variant<string::Epsilon, alphabet::Symbol> inputVariant = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void EpsilonNFA::parseTransition ( std::deque < sax::Token >::iterator & input, EpsilonNFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	std::variant < string::Epsilon, alphabet::Symbol > inputVariant = AutomatonFromXMLParser::parseTransitionInputEpsilonSymbol ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputVariant), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputVariant ), std::move ( to ) );
 }
 
-void EpsilonNFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(EpsilonNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void EpsilonNFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( EpsilonNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialState(out, this->getInitialState());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialState ( out, this->getInitialState ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(EpsilonNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( EpsilonNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void EpsilonNFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		for(const auto& targetState: transition.second) {
-			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void EpsilonNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const auto & transition : this->getTransitions ( ) )
+		for ( const auto & targetState : transition.second ) {
+			out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-			AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-			AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol(out, transition.first.second);
-			AutomatonToXMLComposer::composeTransitionTo(out, targetState);
+			AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+			AutomatonToXMLComposer::composeTransitionInputEpsilonSymbol ( out, transition.first.second );
+			AutomatonToXMLComposer::composeTransitionTo ( out, targetState );
 
-			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+			out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 		}
-	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -311,8 +320,8 @@ 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)
+	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;
@@ -331,14 +340,14 @@ 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)
+	if ( automaton->getInitialState ( ) == state )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( 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))
+	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;
 
 	return false;
@@ -384,12 +393,12 @@ void automaton::EpsilonNFA::Element < automaton::EpsilonNFA, automaton::State, a
 
 namespace alib {
 
-auto epsilonNFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::EpsilonNFA>();
-auto epsilonNFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::EpsilonNFA>();
+auto epsilonNFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::EpsilonNFA > ( );
+auto epsilonNFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::EpsilonNFA > ( );
 
-auto EpsilonNFAFromDFA = castApi::CastRegister<automaton::EpsilonNFA, automaton::DFA>();
-auto EpsilonNFAFromNFA = castApi::CastRegister<automaton::EpsilonNFA, automaton::NFA>();
-auto EpsilonNFAFromMultiInitialStateNFA = castApi::CastRegister<automaton::EpsilonNFA, automaton::MultiInitialStateNFA>();
-auto EpsilonNFACastBinder = castApi::CastPoolStringBinder<automaton::EpsilonNFA>(automaton::EpsilonNFA::XML_TAG_NAME);
+auto EpsilonNFAFromDFA = castApi::CastRegister < automaton::EpsilonNFA, automaton::DFA > ( );
+auto EpsilonNFAFromNFA = castApi::CastRegister < automaton::EpsilonNFA, automaton::NFA > ( );
+auto EpsilonNFAFromMultiInitialStateNFA = castApi::CastRegister < automaton::EpsilonNFA, automaton::MultiInitialStateNFA > ( );
+auto EpsilonNFACastBinder = castApi::CastPoolStringBinder < automaton::EpsilonNFA > ( automaton::EpsilonNFA::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/automaton/FSM/ExtendedNFA.cpp b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
index a7ef321addacd0487a5c2c55da0e30eb4d496f91..f0cd5dd1b3a9b76ed38741ff944397d9afa88484 100644
--- a/alib2data/src/automaton/FSM/ExtendedNFA.cpp
+++ b/alib2data/src/automaton/FSM/ExtendedNFA.cpp
@@ -31,195 +31,198 @@ 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(State initialState) : ExtendedNFA( std::set<State> { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set<State> {} ) {
+ExtendedNFA::ExtendedNFA ( State initialState ) : ExtendedNFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
 }
 
-ExtendedNFA::ExtendedNFA(const CompactNFA& other) : ExtendedNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( transition.first.second )));
+ExtendedNFA::ExtendedNFA ( const CompactNFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
 }
 
-ExtendedNFA::ExtendedNFA(const EpsilonNFA& other) : ExtendedNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		if(transition.first.second.is<string::Epsilon>()) {
-			std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( string::LinearString( std::vector<alphabet::Symbol> { } ) )));
+ExtendedNFA::ExtendedNFA ( const EpsilonNFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		if ( transition.first.second.is < string::Epsilon > ( ) ) {
+			std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
 			transitions[key] = transition.second;
 		} else {
-			std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( transition.first.second.get<alphabet::Symbol>() )));
+			std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second.get < alphabet::Symbol > ( ) ) ) );
 			transitions[key] = transition.second;
 		}
 	}
 }
 
-ExtendedNFA::ExtendedNFA(const MultiInitialStateNFA& other) : ExtendedNFA( other.getStates() + std::set < State > { automaton::createUniqueState(automaton::State("q0"), other.getStates()) }, other.getInputAlphabet(), automaton::createUniqueState(automaton::State("q0"), other.getStates()), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( transition.first.second )));
+ExtendedNFA::ExtendedNFA ( const MultiInitialStateNFA & other ) : ExtendedNFA ( other.getStates ( ) + std::set < State > { automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ) }, other.getInputAlphabet ( ), automaton::createUniqueState ( automaton::State ( "q0" ), other.getStates ( ) ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
-	std::pair<State, regexp::RegExp> key = std::make_pair(this->getInitialState(), regexp::RegExp( regexp::regexpFrom ( string::LinearString(std::vector<alphabet::Symbol> {}) )));
-	transitions[key] = other.getInitialStates();
+
+	std::pair < State, regexp::RegExp > key = std::make_pair ( this->getInitialState ( ), regexp::RegExp ( regexp::regexpFrom ( string::LinearString ( std::vector < alphabet::Symbol > { } ) ) ) );
+	transitions[key] = other.getInitialStates ( );
 }
 
-ExtendedNFA::ExtendedNFA(const NFA& other) : ExtendedNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( transition.first.second )));
+ExtendedNFA::ExtendedNFA ( const NFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
 		transitions[key] = transition.second;
 	}
 }
 
-ExtendedNFA::ExtendedNFA(const DFA& other) : ExtendedNFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		std::pair<State, regexp::RegExp> key = std::make_pair(transition.first.first, regexp::RegExp( regexp::regexpFrom ( transition.first.second )));
-		transitions[key].insert(transition.second);
+ExtendedNFA::ExtendedNFA ( const DFA & other ) : ExtendedNFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) ) {
+		std::pair < State, regexp::RegExp > key = std::make_pair ( transition.first.first, regexp::RegExp ( regexp::regexpFrom ( transition.first.second ) ) );
+		transitions[key].insert ( transition.second );
 	}
 }
 
-AutomatonBase* ExtendedNFA::clone() const {
-	return new ExtendedNFA(*this);
+AutomatonBase * ExtendedNFA::clone ( ) const {
+	return new ExtendedNFA ( * this );
 }
 
-AutomatonBase* ExtendedNFA::plunder() && {
-	return new ExtendedNFA(std::move(*this));
+AutomatonBase * ExtendedNFA::plunder ( ) && {
+	return new ExtendedNFA ( std::move ( * this ) );
 }
 
-bool ExtendedNFA::addTransition(State from, regexp::RegExp input, State to) {
-	if ( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool ExtendedNFA::addTransition ( State from, regexp::RegExp input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	const std::set<alphabet::Symbol>& inputRegExpAlphabet = input.getAlphabet();
+	const std::set < alphabet::Symbol > & inputRegExpAlphabet = input.getAlphabet ( );
 
-	// Transition regexp's alphabet must be subset of automaton's alphabet
-	if (! std::includes(getInputAlphabet().begin(), getInputAlphabet().end(), inputRegExpAlphabet.begin(), inputRegExpAlphabet.end()))
-		throw AutomatonException("Input string is over different alphabet than automaton");
+	 // Transition regexp's alphabet must be subset of automaton's alphabet
+	if ( !std::includes ( getInputAlphabet ( ).begin ( ), getInputAlphabet ( ).end ( ), inputRegExpAlphabet.begin ( ), inputRegExpAlphabet.end ( ) ) )
+		throw AutomatonException ( "Input string is over different alphabet than automaton" );
 
-	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, regexp::RegExp> key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, regexp::RegExp > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	return transitions[std::move(key)].insert(std::move(to)).second;
+	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool ExtendedNFA::removeTransition(const State& from, const regexp::RegExp& input, const State& to) {
-	std::pair<State, regexp::RegExp> key = std::make_pair(from, input);
+bool ExtendedNFA::removeTransition ( const State & from, const regexp::RegExp & input, const State & to ) {
+	std::pair < State, regexp::RegExp > key = std::make_pair ( from, input );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-const std::map<std::pair<State, regexp::RegExp>, std::set<State> >& ExtendedNFA::getTransitions() const {
+const std::map < std::pair < State, regexp::RegExp >, std::set < State > > & ExtendedNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<std::pair<State, regexp::RegExp>, std::set<State> > ExtendedNFA::getTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, regexp::RegExp >, std::set < State > > ExtendedNFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, regexp::RegExp>, std::set<State>> transitionsFromState;
-	for (const std::pair<const std::pair<State, regexp::RegExp>, std::set<State> >& transition : transitions) {
-		if (transition.first.first == from)
-			transitionsFromState.insert(make_pair(transition.first, transition.second));
-	}
+	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, regexp::RegExp >, std::set < State > > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, regexp::RegExp>, std::set<State> > ExtendedNFA::getTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, regexp::RegExp >, std::set < State > > ExtendedNFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, regexp::RegExp>, std::set<State>> transitionsToState;
-	for (const std::pair<const std::pair<State, regexp::RegExp>, std::set<State> >& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end())
-			transitionsToState.insert(make_pair(transition.first, transition.second));
-	}
+	std::map < std::pair < State, regexp::RegExp >, std::set < State > > transitionsToState;
+
+	for ( const std::pair < const std::pair < State, regexp::RegExp >, std::set < State > > & transition : transitions )
+		if ( transition.second.find ( to ) != transition.second.end ( ) )
+			transitionsToState.insert ( make_pair ( transition.first, transition.second ) );
 
 	return transitionsToState;
 }
 
-int ExtendedNFA::compare(const ExtendedNFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialState(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates(), other.getTransitions());
+int ExtendedNFA::compare ( const ExtendedNFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialState ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ), other.getTransitions ( ) );
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
 }
 
-void ExtendedNFA::operator>>(std::ostream& out) const {
+void ExtendedNFA::operator >>( std::ostream & out ) const {
 	out << "(ExtendedNFA "
-		<< "states = " << getStates()
-		<< "inputAlphabet = " << getInputAlphabet()
-		<< "initialState = " << getInitialState()
-		<< "finalStates = " << getFinalStates()
-		<< "transitions = " << transitions
-		<< ")";
+	    << "states = " << getStates ( )
+	    << "inputAlphabet = " << getInputAlphabet ( )
+	    << "initialState = " << getInitialState ( )
+	    << "finalStates = " << getFinalStates ( )
+	    << "transitions = " << transitions
+	    << ")";
 }
 
-ExtendedNFA::operator std::string () const {
+ExtendedNFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string ExtendedNFA::XML_TAG_NAME = "ExtendedNFA";
 
-ExtendedNFA ExtendedNFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, ExtendedNFA::XML_TAG_NAME);
+ExtendedNFA ExtendedNFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, ExtendedNFA::XML_TAG_NAME );
+
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	ExtendedNFA automaton ( std::move ( initialState ) );
 
-	ExtendedNFA automaton(std::move(initialState));
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setFinalStates(std::move(finalStates));
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
 
-	AutomatonFromXMLParser::parseTransitions<ExtendedNFA>(input, automaton);
+	AutomatonFromXMLParser::parseTransitions < ExtendedNFA > ( input, automaton );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, ExtendedNFA::XML_TAG_NAME);
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, ExtendedNFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void ExtendedNFA::parseTransition(std::deque<sax::Token>::iterator& input, ExtendedNFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	regexp::RegExp inputRegexp = AutomatonFromXMLParser::parseTransitionInputRegexp(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void ExtendedNFA::parseTransition ( std::deque < sax::Token >::iterator & input, ExtendedNFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	regexp::RegExp inputRegexp = AutomatonFromXMLParser::parseTransitionInputRegexp ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputRegexp), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputRegexp ), std::move ( to ) );
 }
 
-void ExtendedNFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(ExtendedNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void ExtendedNFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( ExtendedNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialState(out, this->getInitialState());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialState ( out, this->getInitialState ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(ExtendedNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( ExtendedNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void ExtendedNFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		for(const auto& targetState: transition.second) {
-			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void ExtendedNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
 
-			AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-			AutomatonToXMLComposer::composeTransitionInputRegexp(out, transition.first.second);
-			AutomatonToXMLComposer::composeTransitionTo(out, targetState);
+	for ( const auto & transition : this->getTransitions ( ) )
+		for ( const auto & targetState : transition.second ) {
+			out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+			AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+			AutomatonToXMLComposer::composeTransitionInputRegexp ( out, transition.first.second );
+			AutomatonToXMLComposer::composeTransitionTo ( out, targetState );
+
+			out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 		}
-	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -230,8 +233,8 @@ 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 );
 
-	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)
+	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;
@@ -250,14 +253,14 @@ 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 );
 
-	if (automaton->getInitialState() == state)
+	if ( automaton->getInitialState ( ) == state )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( 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())
+	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;
@@ -303,14 +306,14 @@ void automaton::ExtendedNFA::Element < automaton::ExtendedNFA, automaton::State,
 
 namespace alib {
 
-auto extendedNFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::ExtendedNFA>();
-auto extendedNFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::ExtendedNFA>();
+auto extendedNFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::ExtendedNFA > ( );
+auto extendedNFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::ExtendedNFA > ( );
 
-auto ExtendedNFAFromDFA = castApi::CastRegister<automaton::ExtendedNFA, automaton::DFA>();
-auto ExtendedNFAFromNFA = castApi::CastRegister<automaton::ExtendedNFA, automaton::NFA>();
-auto ExtendedNFAFromMultiInitialStateNFA = castApi::CastRegister<automaton::ExtendedNFA, automaton::MultiInitialStateNFA>();
-auto ExtendedNFAEpsilonNFA = castApi::CastRegister<automaton::ExtendedNFA, automaton::EpsilonNFA>();
-auto ExtendedNFACompactNFA = castApi::CastRegister<automaton::ExtendedNFA, automaton::CompactNFA>();
-auto ExtendedNFACastBinder = castApi::CastPoolStringBinder<automaton::ExtendedNFA>(automaton::ExtendedNFA::XML_TAG_NAME);
+auto ExtendedNFAFromDFA = castApi::CastRegister < automaton::ExtendedNFA, automaton::DFA > ( );
+auto ExtendedNFAFromNFA = castApi::CastRegister < automaton::ExtendedNFA, automaton::NFA > ( );
+auto ExtendedNFAFromMultiInitialStateNFA = castApi::CastRegister < automaton::ExtendedNFA, automaton::MultiInitialStateNFA > ( );
+auto ExtendedNFAEpsilonNFA = castApi::CastRegister < automaton::ExtendedNFA, automaton::EpsilonNFA > ( );
+auto ExtendedNFACompactNFA = castApi::CastRegister < automaton::ExtendedNFA, automaton::CompactNFA > ( );
+auto ExtendedNFACastBinder = castApi::CastPoolStringBinder < automaton::ExtendedNFA > ( automaton::ExtendedNFA::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
index d7c1efcdefa1348f4aeea7a423a01be1c4cbae34..6cb1fce7938cd9b62f8fe15a39b5c9adbbe8c624 100644
--- a/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
+++ b/alib2data/src/automaton/FSM/MultiInitialStateNFA.cpp
@@ -25,183 +25,184 @@ 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, FinalStates, InitialStates >, std::tuple < > > ( std::make_tuple ( std::move ( inputAlphabet ) ), std::tuple < > ( ), std::make_tuple ( std::move ( states ), std::move ( finalStates ), std::move ( initialStates ) ), std::tuple < > ( ) ) {
 }
 
-MultiInitialStateNFA::MultiInitialStateNFA() : MultiInitialStateNFA( std::set<State> { }, std::set < alphabet::Symbol > { }, std::set < State > { } , std::set<State> {} ) {
+MultiInitialStateNFA::MultiInitialStateNFA ( ) : MultiInitialStateNFA ( std::set < State > { }, std::set < alphabet::Symbol > { }, std::set < State > { }, std::set < State > { } ) {
 }
 
-MultiInitialStateNFA::MultiInitialStateNFA(const DFA& other) : MultiInitialStateNFA( other.getStates(), other.getInputAlphabet(), { other.getInitialState() }, other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		transitions[transition.first].insert(transition.second);
-	}
+MultiInitialStateNFA::MultiInitialStateNFA ( const DFA & other ) : MultiInitialStateNFA ( other.getStates ( ), other.getInputAlphabet ( ), { other.getInitialState ( ) }, other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) )
+		transitions[transition.first].insert ( transition.second );
 }
 
-MultiInitialStateNFA::MultiInitialStateNFA(const NFA& other) : MultiInitialStateNFA( other.getStates(), other.getInputAlphabet(), { other.getInitialState() }, other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
+MultiInitialStateNFA::MultiInitialStateNFA ( const NFA & other ) : MultiInitialStateNFA ( other.getStates ( ), other.getInputAlphabet ( ), { other.getInitialState ( ) }, other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) )
 		transitions[transition.first] = transition.second;
-	}
 }
 
-AutomatonBase* MultiInitialStateNFA::clone() const {
-	return new MultiInitialStateNFA(*this);
+AutomatonBase * MultiInitialStateNFA::clone ( ) const {
+	return new MultiInitialStateNFA ( * this );
 }
 
-AutomatonBase* MultiInitialStateNFA::plunder() && {
-	return new MultiInitialStateNFA(std::move(*this));
+AutomatonBase * MultiInitialStateNFA::plunder ( ) && {
+	return new MultiInitialStateNFA ( std::move ( * this ) );
 }
 
-bool MultiInitialStateNFA::addTransition(State from, alphabet::Symbol input, State to) {
-	if (!getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool MultiInitialStateNFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	if (!getInputAlphabet().count(input))
-		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
+	if ( !getInputAlphabet ( ).count ( input ) )
+		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
-	if (!getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	return transitions[std::move(key)].insert(std::move(to)).second;
+	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool MultiInitialStateNFA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool MultiInitialStateNFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::set<State> >& MultiInitialStateNFA::getTransitions() const {
+const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & MultiInitialStateNFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > MultiInitialStateNFA::getTransitionsFromState(const State& from) const {
-	if( ! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > MultiInitialStateNFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsFromState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
-		if (transition.first.first == from)
-			transitionsFromState[transition.first].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > MultiInitialStateNFA::getTransitionsToState(const State& to) const {
-	if( ! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > MultiInitialStateNFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
-		if (transition.second.find(to) != transition.second.end())
-			transitionsToState[transition.first].insert(transition.second.begin(), transition.second.end());
-	}
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.second.find ( to ) != transition.second.end ( ) )
+			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-bool MultiInitialStateNFA::isDeterministic() const {
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions)
-		if (transition.second.size() > 1)
+bool MultiInitialStateNFA::isDeterministic ( ) const {
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.second.size ( ) > 1 )
 			return false;
 
-	return getInitialStates().size() == 1;
+	return getInitialStates ( ).size ( ) == 1;
 }
 
-bool MultiInitialStateNFA::isTotal() const {
-	return isDeterministic() && transitionsSize() == getInputAlphabet().size() * getStates().size();
+bool MultiInitialStateNFA::isTotal ( ) const {
+	return isDeterministic ( ) && transitionsSize ( ) == getInputAlphabet ( ).size ( ) * getStates ( ).size ( );
 }
 
-unsigned MultiInitialStateNFA::transitionsSize() const {
+unsigned MultiInitialStateNFA::transitionsSize ( ) const {
 	int res = 0;
-	for(const auto& transition : transitions ){
-		res += transition.second.size();
-	}
+
+	for ( const auto & transition : transitions )
+		res += transition.second.size ( );
+
 	return res;
 }
 
-int MultiInitialStateNFA::compare(const MultiInitialStateNFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialStates(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialStates(), other.getFinalStates(), other.getTransitions());
+int MultiInitialStateNFA::compare ( const MultiInitialStateNFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialStates ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialStates ( ), other.getFinalStates ( ), other.getTransitions ( ) );
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
 }
 
-void MultiInitialStateNFA::operator>>(std::ostream& out) const {
+void MultiInitialStateNFA::operator >>( std::ostream & out ) const {
 	out << "(MultiInitialStateNFA "
-		<< "states = " << getStates()
-		<< "inputAlphabet = " << getInputAlphabet()
-		<< "initialStates = " << getInitialStates()
-		<< "finalStates = " << getFinalStates()
-		<< "transitions = " << transitions
-		<< ")";
+	    << "states = " << getStates ( )
+	    << "inputAlphabet = " << getInputAlphabet ( )
+	    << "initialStates = " << getInitialStates ( )
+	    << "finalStates = " << getFinalStates ( )
+	    << "transitions = " << transitions
+	    << ")";
 }
 
-MultiInitialStateNFA::operator std::string () const {
+MultiInitialStateNFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string MultiInitialStateNFA::XML_TAG_NAME = "MultiInitialStateNFA";
 
-MultiInitialStateNFA MultiInitialStateNFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, MultiInitialStateNFA::XML_TAG_NAME);
+MultiInitialStateNFA MultiInitialStateNFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, MultiInitialStateNFA::XML_TAG_NAME );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	std::set<State> initialStates = AutomatonFromXMLParser::parseInitialStates(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	std::set < State > initialStates = AutomatonFromXMLParser::parseInitialStates ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
 	MultiInitialStateNFA automaton;
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setInitialStates(std::move(initialStates));
-	automaton.setFinalStates(std::move(finalStates));
 
-	AutomatonFromXMLParser::parseTransitions<MultiInitialStateNFA>(input, automaton);
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setInitialStates ( std::move ( initialStates ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
+
+	AutomatonFromXMLParser::parseTransitions < MultiInitialStateNFA > ( input, automaton );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, MultiInitialStateNFA::XML_TAG_NAME);
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, MultiInitialStateNFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void MultiInitialStateNFA::parseTransition(std::deque<sax::Token>::iterator& input, MultiInitialStateNFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void MultiInitialStateNFA::parseTransition ( std::deque < sax::Token >::iterator & input, MultiInitialStateNFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
 }
 
-void MultiInitialStateNFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(MultiInitialStateNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void MultiInitialStateNFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( MultiInitialStateNFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialStates(out, this->getInitialStates());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialStates ( out, this->getInitialStates ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(MultiInitialStateNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( MultiInitialStateNFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void MultiInitialStateNFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		for(const auto& targetState: transition.second) {
-			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void MultiInitialStateNFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const auto & transition : this->getTransitions ( ) )
+		for ( const auto & targetState : transition.second ) {
+			out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-			AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-			AutomatonToXMLComposer::composeTransitionInputSymbol(out, transition.first.second);
-			AutomatonToXMLComposer::composeTransitionTo(out, targetState);
+			AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+			AutomatonToXMLComposer::composeTransitionInputSymbol ( out, transition.first.second );
+			AutomatonToXMLComposer::composeTransitionTo ( out, targetState );
 
-			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+			out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 		}
-	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -212,8 +213,8 @@ 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 );
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& transition : automaton->getTransitions())
-		if (transition.first.second == 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;
@@ -232,14 +233,14 @@ 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))
+	if ( automaton->getInitialStates ( ).count ( state ) )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( 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())
+	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;
@@ -290,11 +291,11 @@ void automaton::MultiInitialStateNFA::Component < automaton::MultiInitialStateNF
 
 namespace alib {
 
-auto multiInitialStateNFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::MultiInitialStateNFA>();
-auto multiInitialStateNFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::MultiInitialStateNFA>();
+auto multiInitialStateNFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::MultiInitialStateNFA > ( );
+auto multiInitialStateNFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::MultiInitialStateNFA > ( );
 
-auto MultiInitialStateNFAFromDFA = castApi::CastRegister<automaton::MultiInitialStateNFA, automaton::DFA>();
-auto MultiInitialStateNFAFromNFA = castApi::CastRegister<automaton::MultiInitialStateNFA, automaton::NFA>();
-auto MultiInitialStateNFACastBinder = castApi::CastPoolStringBinder<automaton::MultiInitialStateNFA>(automaton::MultiInitialStateNFA::XML_TAG_NAME);
+auto MultiInitialStateNFAFromDFA = castApi::CastRegister < automaton::MultiInitialStateNFA, automaton::DFA > ( );
+auto MultiInitialStateNFAFromNFA = castApi::CastRegister < automaton::MultiInitialStateNFA, automaton::NFA > ( );
+auto MultiInitialStateNFACastBinder = castApi::CastPoolStringBinder < automaton::MultiInitialStateNFA > ( automaton::MultiInitialStateNFA::XML_TAG_NAME );
 
 } /* namespace alib */
diff --git a/alib2data/src/automaton/FSM/NFA.cpp b/alib2data/src/automaton/FSM/NFA.cpp
index 47a077665c8b56e9eee3a87d980bf3a9ab49c231..f64446db63a0b88af5eee05f5d025cc83574384d 100644
--- a/alib2data/src/automaton/FSM/NFA.cpp
+++ b/alib2data/src/automaton/FSM/NFA.cpp
@@ -23,175 +23,178 @@ 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(State initialState) : NFA( std::set<State> { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set<State> {} ) {
+NFA::NFA ( State initialState ) : NFA ( std::set < State > { initialState }, std::set < alphabet::Symbol > { }, initialState, std::set < State > { } ) {
 }
 
-NFA::NFA(const DFA& other) : NFA( other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates() ) {
-	for(const auto& transition : other.getTransitions()) {
-		transitions[transition.first].insert(transition.second);
-	}
+NFA::NFA ( const DFA & other ) : NFA ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ) ) {
+	for ( const auto & transition : other.getTransitions ( ) )
+		transitions[transition.first].insert ( transition.second );
 }
 
-AutomatonBase* NFA::clone() const {
-	return new NFA(*this);
+AutomatonBase * NFA::clone ( ) const {
+	return new NFA ( * this );
 }
 
-AutomatonBase* NFA::plunder() && {
-	return new NFA(std::move(*this));
+AutomatonBase * NFA::plunder ( ) && {
+	return new NFA ( std::move ( * this ) );
 }
 
-bool NFA::addTransition(State from, alphabet::Symbol input, State to) {
-	if (! getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist.");
+bool NFA::addTransition ( State from, alphabet::Symbol input, State to ) {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist." );
 
-	if (! getInputAlphabet().count(input))
-		throw AutomatonException("Input symbol \"" + (std::string) input + "\" doesn't exist.");
+	if ( !getInputAlphabet ( ).count ( input ) )
+		throw AutomatonException ( "Input symbol \"" + ( std::string ) input + "\" doesn't exist." );
 
-	if (! getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist.");
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist." );
 
-	std::pair<State, alphabet::Symbol> key = std::make_pair(std::move(from), std::move(input));
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( std::move ( from ), std::move ( input ) );
 
-	return transitions[std::move(key)].insert(std::move(to)).second;
+	return transitions[std::move ( key )].insert ( std::move ( to ) ).second;
 }
 
-bool NFA::removeTransition(const State& from, const alphabet::Symbol& input, const State& to) {
-	std::pair<State, alphabet::Symbol> key = std::make_pair(from, input);
+bool NFA::removeTransition ( const State & from, const alphabet::Symbol & input, const State & to ) {
+	std::pair < State, alphabet::Symbol > key = std::make_pair ( from, input );
 
-	return transitions[key].erase(to);
+	return transitions[key].erase ( to );
 }
 
-const std::map<std::pair<State, alphabet::Symbol>, std::set<State> >& NFA::getTransitions() const {
+const std::map < std::pair < State, alphabet::Symbol >, std::set < State > > & NFA::getTransitions ( ) const {
 	return transitions;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > NFA::getTransitionsFromState(const State& from) const {
-	if( !getStates().count(from))
-		throw AutomatonException("State \"" + (std::string) from.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > NFA::getTransitionsFromState ( const State & from ) const {
+	if ( !getStates ( ).count ( from ) )
+		throw AutomatonException ( "State \"" + ( std::string ) from.getName ( ) + "\" doesn't exist" );
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsFromState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions) {
-		if (transition.first.first == from)
-			transitionsFromState[transition.first].insert(transition.second.begin(), transition.second.end());
-	}
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsFromState;
+
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.first.first == from )
+			transitionsFromState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsFromState;
 }
 
-std::map<std::pair<State, alphabet::Symbol>, std::set<State> > NFA::getTransitionsToState(const State& to) const {
-	if( !getStates().count(to))
-		throw AutomatonException("State \"" + (std::string) to.getName() + "\" doesn't exist");
+std::map < std::pair < State, alphabet::Symbol >, std::set < State > > NFA::getTransitionsToState ( const State & to ) const {
+	if ( !getStates ( ).count ( to ) )
+		throw AutomatonException ( "State \"" + ( std::string ) to.getName ( ) + "\" doesn't exist" );
+
+	std::map < std::pair < State, alphabet::Symbol >, std::set < State > > transitionsToState;
 
-	std::map<std::pair<State, alphabet::Symbol>, std::set<State> > transitionsToState;
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions)
-		if (transition.second.find(to) != transition.second.end())
-			transitionsToState[transition.first].insert(transition.second.begin(), transition.second.end());
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.second.find ( to ) != transition.second.end ( ) )
+			transitionsToState[transition.first].insert ( transition.second.begin ( ), transition.second.end ( ) );
 
 	return transitionsToState;
 }
 
-bool NFA::isDeterministic() const {
-	for (const std::pair<const std::pair<State, alphabet::Symbol>, std::set<State> >& transition : transitions)
-		if (transition.second.size() > 1)
+bool NFA::isDeterministic ( ) const {
+	for ( const std::pair < const std::pair < State, alphabet::Symbol >, std::set < State > > & transition : transitions )
+		if ( transition.second.size ( ) > 1 )
 			return false;
 
 	return true;
 }
 
-bool NFA::isTotal() const {
-	return isDeterministic() && transitionsSize() == getInputAlphabet().size() * getStates().size();
+bool NFA::isTotal ( ) const {
+	return isDeterministic ( ) && transitionsSize ( ) == getInputAlphabet ( ).size ( ) * getStates ( ).size ( );
 }
 
-unsigned NFA::transitionsSize() const {
+unsigned NFA::transitionsSize ( ) const {
 	int res = 0;
-	for(const auto& transition : transitions ){
-		res += transition.second.size();
-	}
+
+	for ( const auto & transition : transitions )
+		res += transition.second.size ( );
+
 	return res;
 }
 
-int NFA::compare(const NFA& other) const {
-	auto first = std::tie(getStates(), getInputAlphabet(), getInitialState(), getFinalStates(), transitions);
-	auto second = std::tie(other.getStates(), other.getInputAlphabet(), other.getInitialState(), other.getFinalStates(), other.getTransitions());
+int NFA::compare ( const NFA & other ) const {
+	auto first = std::tie ( getStates ( ), getInputAlphabet ( ), getInitialState ( ), getFinalStates ( ), transitions );
+	auto second = std::tie ( other.getStates ( ), other.getInputAlphabet ( ), other.getInitialState ( ), other.getFinalStates ( ), other.getTransitions ( ) );
 
-	std::compare<decltype(first)> comp;
-	return comp(first, second);
+	std::compare < decltype ( first ) > comp;
+
+	return comp ( first, second );
 }
 
-void NFA::operator>>(std::ostream& out) const {
+void NFA::operator >>( std::ostream & out ) const {
 	out << "(NFA "
-		<< "states = " << getStates()
-		<< "inputAlphabet = " << getInputAlphabet()
-		<< "initialState = " << getInitialState()
-		<< "finalStates = " << getFinalStates()
-		<< "transitions = " << transitions
-		<< ")";
+	    << "states = " << getStates ( )
+	    << "inputAlphabet = " << getInputAlphabet ( )
+	    << "initialState = " << getInitialState ( )
+	    << "finalStates = " << getFinalStates ( )
+	    << "transitions = " << transitions
+	    << ")";
 }
 
-NFA::operator std::string () const {
+NFA::operator std::string ( ) const {
 	std::stringstream ss;
-	ss << *this;
-	return ss.str();
+	ss << * this;
+	return ss.str ( );
 }
 
 const std::string NFA::XML_TAG_NAME = "NFA";
 
-NFA NFA::parse(std::deque<sax::Token>::iterator& input) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, NFA::XML_TAG_NAME);
+NFA NFA::parse ( std::deque < sax::Token >::iterator & input ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, NFA::XML_TAG_NAME );
+
+	std::set < State > states = AutomatonFromXMLParser::parseStates ( input );
+	std::set < alphabet::Symbol > inputSymbols = AutomatonFromXMLParser::parseInputAlphabet ( input );
+	State initialState = AutomatonFromXMLParser::parseInitialState ( input );
+	std::set < State > finalStates = AutomatonFromXMLParser::parseFinalStates ( input );
 
-	std::set<State> states = AutomatonFromXMLParser::parseStates(input);
-	std::set<alphabet::Symbol> inputSymbols = AutomatonFromXMLParser::parseInputAlphabet(input);
-	State initialState = AutomatonFromXMLParser::parseInitialState(input);
-	std::set<State> finalStates = AutomatonFromXMLParser::parseFinalStates(input);
+	NFA automaton ( std::move ( initialState ) );
 
-	NFA automaton(std::move(initialState));
-	automaton.setStates(std::move(states));
-	automaton.setInputAlphabet(std::move(inputSymbols));
-	automaton.setFinalStates(std::move(finalStates));
+	automaton.setStates ( std::move ( states ) );
+	automaton.setInputAlphabet ( std::move ( inputSymbols ) );
+	automaton.setFinalStates ( std::move ( finalStates ) );
 
-	AutomatonFromXMLParser::parseTransitions<NFA>(input, automaton);
+	AutomatonFromXMLParser::parseTransitions < NFA > ( input, automaton );
 
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, NFA::XML_TAG_NAME);
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, NFA::XML_TAG_NAME );
 	return automaton;
 }
 
-void NFA::parseTransition(std::deque<sax::Token>::iterator& input, NFA& automaton) {
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::START_ELEMENT, "transition");
-	State from = AutomatonFromXMLParser::parseTransitionFrom(input);
-	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol(input);
-	State to = AutomatonFromXMLParser::parseTransitionTo(input);
-	sax::FromXMLParserHelper::popToken(input, sax::Token::TokenType::END_ELEMENT, "transition");
+void NFA::parseTransition ( std::deque < sax::Token >::iterator & input, NFA & automaton ) {
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::START_ELEMENT, "transition" );
+	State from = AutomatonFromXMLParser::parseTransitionFrom ( input );
+	alphabet::Symbol inputSymbol = AutomatonFromXMLParser::parseTransitionInputSymbol ( input );
+	State to = AutomatonFromXMLParser::parseTransitionTo ( input );
+	sax::FromXMLParserHelper::popToken ( input, sax::Token::TokenType::END_ELEMENT, "transition" );
 
-	automaton.addTransition(std::move(from), std::move(inputSymbol), std::move(to));
+	automaton.addTransition ( std::move ( from ), std::move ( inputSymbol ), std::move ( to ) );
 }
 
-void NFA::compose(std::deque<sax::Token>& out) const {
-	out.emplace_back(NFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT);
+void NFA::compose ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( NFA::XML_TAG_NAME, sax::Token::TokenType::START_ELEMENT );
 
-	AutomatonToXMLComposer::composeStates(out, this->getStates());
-	AutomatonToXMLComposer::composeInputAlphabet(out, this->getInputAlphabet());
-	AutomatonToXMLComposer::composeInitialState(out, this->getInitialState());
-	AutomatonToXMLComposer::composeFinalStates(out, this->getFinalStates());
-	composeTransitions(out);
+	AutomatonToXMLComposer::composeStates ( out, this->getStates ( ) );
+	AutomatonToXMLComposer::composeInputAlphabet ( out, this->getInputAlphabet ( ) );
+	AutomatonToXMLComposer::composeInitialState ( out, this->getInitialState ( ) );
+	AutomatonToXMLComposer::composeFinalStates ( out, this->getFinalStates ( ) );
+	composeTransitions ( out );
 
-	out.emplace_back(NFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( NFA::XML_TAG_NAME, sax::Token::TokenType::END_ELEMENT );
 }
 
-void NFA::composeTransitions(std::deque<sax::Token>& out) const {
-	out.emplace_back("transitions", sax::Token::TokenType::START_ELEMENT);
-	for(const auto& transition : this->getTransitions()) {
-		for(const auto& targetState: transition.second) {
-			out.emplace_back("transition", sax::Token::TokenType::START_ELEMENT);
+void NFA::composeTransitions ( std::deque < sax::Token > & out ) const {
+	out.emplace_back ( "transitions", sax::Token::TokenType::START_ELEMENT );
+
+	for ( const auto & transition : this->getTransitions ( ) )
+		for ( const auto & targetState : transition.second ) {
+			out.emplace_back ( "transition", sax::Token::TokenType::START_ELEMENT );
 
-			AutomatonToXMLComposer::composeTransitionFrom(out, transition.first.first);
-			AutomatonToXMLComposer::composeTransitionInputSymbol(out, transition.first.second);
-			AutomatonToXMLComposer::composeTransitionTo(out, targetState);
+			AutomatonToXMLComposer::composeTransitionFrom ( out, transition.first.first );
+			AutomatonToXMLComposer::composeTransitionInputSymbol ( out, transition.first.second );
+			AutomatonToXMLComposer::composeTransitionTo ( out, targetState );
 
-			out.emplace_back("transition", sax::Token::TokenType::END_ELEMENT);
+			out.emplace_back ( "transition", sax::Token::TokenType::END_ELEMENT );
 		}
-	}
 
-	out.emplace_back("transitions", sax::Token::TokenType::END_ELEMENT);
+	out.emplace_back ( "transitions", sax::Token::TokenType::END_ELEMENT );
 }
 
 } /* namespace automaton */
@@ -202,8 +205,8 @@ 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 );
 
-	for (const std::pair<const std::pair<automaton::State, alphabet::Symbol>, std::set<automaton::State> >& transition : automaton->getTransitions())
-		if (transition.first.second == 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;
@@ -222,14 +225,14 @@ 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 );
 
-	if (automaton->getInitialState() == state)
+	if ( automaton->getInitialState ( ) == state )
 		return true;
 
-	if (automaton->getFinalStates().count(state))
+	if ( automaton->getFinalStates ( ).count ( 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())
+	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;
@@ -275,10 +278,10 @@ void automaton::NFA::Element < automaton::NFA, automaton::State, automaton::Init
 
 namespace alib {
 
-auto NFAParserRegister = xmlApi<automaton::Automaton>::ParserRegister<automaton::NFA>();
-auto NFAParserRegister2 = xmlApi<alib::Object>::ParserRegister<automaton::NFA>();
+auto NFAParserRegister = xmlApi < automaton::Automaton >::ParserRegister < automaton::NFA > ( );
+auto NFAParserRegister2 = xmlApi < alib::Object >::ParserRegister < automaton::NFA > ( );
 
-auto NFAFromDFA = castApi::CastRegister<automaton::NFA, automaton::DFA>();
-auto NFACastBinder = castApi::CastPoolStringBinder<automaton::NFA>(automaton::NFA::XML_TAG_NAME);
+auto NFAFromDFA = castApi::CastRegister < automaton::NFA, automaton::DFA > ( );
+auto NFACastBinder = castApi::CastPoolStringBinder < automaton::NFA > ( automaton::NFA::XML_TAG_NAME );
 
 } /* namespace alib */