diff --git a/aaccess2/src/AutomatonAccess.cpp b/aaccess2/src/AutomatonAccess.cpp
index c4ec1590d779934c259f6742c72fbbb2ca7d8553..a47ece4fe568d85f1419c0652908266b843a7e98 100644
--- a/aaccess2/src/AutomatonAccess.cpp
+++ b/aaccess2/src/AutomatonAccess.cpp
@@ -26,6 +26,7 @@
 #include <container/ObjectsTree.h>
 
 #include "common/AccessHelpers.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 void AutomatonAccess::access ( automaton::Automaton & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	dispatch ( automaton.getData ( ), settings, operation, argument );
@@ -50,7 +51,7 @@ void AutomatonAccess::access ( automaton::NFA < > & automaton, const AutomatonSe
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessNFA = AutomatonAccess::RegistratorWrapper < void, automaton::NFA < > > ( AutomatonAccess::access );
+auto AutomatonAccessNFA = registration::OverloadRegister < AutomatonAccess, void, automaton::NFA < > > ( AutomatonAccess::access );
 
 void AutomatonAccess::access ( automaton::DFA<> & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == AutomatonSettings::Settings::STATES )
@@ -71,7 +72,7 @@ void AutomatonAccess::access ( automaton::DFA<> & automaton, const AutomatonSett
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessDFA = AutomatonAccess::RegistratorWrapper < void, automaton::DFA<> > ( AutomatonAccess::access );
+auto AutomatonAccessDFA = registration::OverloadRegister < AutomatonAccess, void, automaton::DFA<> > ( AutomatonAccess::access );
 
 void AutomatonAccess::access ( automaton::InputDrivenNPDA < > & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == AutomatonSettings::Settings::STATES )
@@ -92,7 +93,7 @@ void AutomatonAccess::access ( automaton::InputDrivenNPDA < > & automaton, const
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessInputDrivenNPDA = AutomatonAccess::RegistratorWrapper < void, automaton::InputDrivenNPDA < > > ( AutomatonAccess::access );
+auto AutomatonAccessInputDrivenNPDA = registration::OverloadRegister < AutomatonAccess, void, automaton::InputDrivenNPDA < > > ( AutomatonAccess::access );
 
 void AutomatonAccess::access ( automaton::InputDrivenDPDA < > & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == AutomatonSettings::Settings::STATES )
@@ -113,7 +114,7 @@ void AutomatonAccess::access ( automaton::InputDrivenDPDA < > & automaton, const
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessInputDrivenDPDA = AutomatonAccess::RegistratorWrapper < void, automaton::InputDrivenDPDA < > > ( AutomatonAccess::access );
+auto AutomatonAccessInputDrivenDPDA = registration::OverloadRegister < AutomatonAccess, void, automaton::InputDrivenDPDA < > > ( AutomatonAccess::access );
 
 void AutomatonAccess::access ( automaton::NPDA < > & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == AutomatonSettings::Settings::STATES )
@@ -134,7 +135,7 @@ void AutomatonAccess::access ( automaton::NPDA < > & automaton, const AutomatonS
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessNPDA = AutomatonAccess::RegistratorWrapper < void, automaton::NPDA < > > ( AutomatonAccess::access );
+auto AutomatonAccessNPDA = registration::OverloadRegister < AutomatonAccess, void, automaton::NPDA < > > ( AutomatonAccess::access );
 
 void AutomatonAccess::access ( automaton::DPDA < > & automaton, const AutomatonSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == AutomatonSettings::Settings::STATES )
@@ -155,4 +156,4 @@ void AutomatonAccess::access ( automaton::DPDA < > & automaton, const AutomatonS
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto AutomatonAccessDPDA = AutomatonAccess::RegistratorWrapper < void, automaton::DPDA < > > ( AutomatonAccess::access );
+auto AutomatonAccessDPDA = registration::OverloadRegister < AutomatonAccess, void, automaton::DPDA < > > ( AutomatonAccess::access );
diff --git a/aaccess2/src/GrammarAccess.cpp b/aaccess2/src/GrammarAccess.cpp
index 3a8002921d55346ec4daa56decd1da0cbed3deea..2704a566ca72e88a35ad93d0ccadd47388cedff6 100644
--- a/aaccess2/src/GrammarAccess.cpp
+++ b/aaccess2/src/GrammarAccess.cpp
@@ -20,6 +20,7 @@
 #include <container/ObjectsTree.h>
 
 #include "common/AccessHelpers.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 void GrammarAccess::access ( grammar::Grammar & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	dispatch ( grammar.getData ( ), settings, operation, argument );
@@ -41,7 +42,7 @@ void GrammarAccess::access ( grammar::RightRG < > & grammar, const GrammarSettin
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto GrammarAccessRightRG = GrammarAccess::RegistratorWrapper < void, grammar::RightRG < > > ( GrammarAccess::access );
+auto GrammarAccessRightRG = registration::OverloadRegister < GrammarAccess, void, grammar::RightRG < > > ( GrammarAccess::access );
 
 void GrammarAccess::access ( grammar::RightLG < > & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == GrammarSettings::Settings::NONTERMINALS )
@@ -59,4 +60,4 @@ void GrammarAccess::access ( grammar::RightLG < > & grammar, const GrammarSettin
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto GrammarAccessRightLG = GrammarAccess::RegistratorWrapper < void, grammar::RightLG < > > ( GrammarAccess::access );
+auto GrammarAccessRightLG = registration::OverloadRegister < GrammarAccess, void, grammar::RightLG < > > ( GrammarAccess::access );
diff --git a/aaccess2/src/RegExpAccess.cpp b/aaccess2/src/RegExpAccess.cpp
index b2a8aa3113c4ec763ab79e0944a9b55071e1a0d9..cee1a7cd0f654324eabc42212e42d0a0fa999a98 100644
--- a/aaccess2/src/RegExpAccess.cpp
+++ b/aaccess2/src/RegExpAccess.cpp
@@ -24,6 +24,7 @@
 #include <container/ObjectsTree.h>
 
 #include "common/AccessHelpers.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 void RegExpAccess::access ( regexp::RegExp & regexp, const RegExpSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	dispatch ( regexp.getData ( ), settings, operation, argument );
@@ -38,7 +39,7 @@ void RegExpAccess::access ( regexp::FormalRegExp < > & regexp, const RegExpSetti
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto RegExpAccessFormalRegExp = RegExpAccess::RegistratorWrapper < void, regexp::FormalRegExp < > > ( RegExpAccess::access );
+auto RegExpAccessFormalRegExp = registration::OverloadRegister < RegExpAccess, void, regexp::FormalRegExp < > > ( RegExpAccess::access );
 
 void RegExpAccess::access ( regexp::UnboundedRegExp < > & regexp, const RegExpSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == RegExpSettings::Settings::ALPHABET )
@@ -49,4 +50,4 @@ void RegExpAccess::access ( regexp::UnboundedRegExp < > & regexp, const RegExpSe
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto RegExpAccessUnboundedRegExp = RegExpAccess::RegistratorWrapper < void, regexp::UnboundedRegExp < > > ( RegExpAccess::access );
+auto RegExpAccessUnboundedRegExp = registration::OverloadRegister < RegExpAccess, void, regexp::UnboundedRegExp < > > ( RegExpAccess::access );
diff --git a/aaccess2/src/StringAccess.cpp b/aaccess2/src/StringAccess.cpp
index 217ad73a06565241251bf5b98ed78b56567de8ed..87a2eef0d37d1ad1a4bffdf7e6749cb44cbae4c0 100644
--- a/aaccess2/src/StringAccess.cpp
+++ b/aaccess2/src/StringAccess.cpp
@@ -20,6 +20,7 @@
 #include <container/ObjectsTree.h>
 
 #include "common/AccessHelpers.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 void StringAccess::access ( string::String & string, const StringSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	dispatch ( string.getData ( ), settings, operation, argument );
@@ -35,7 +36,7 @@ void StringAccess::access ( string::LinearString < > & string, const StringSetti
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto StringAccessFormalString = StringAccess::RegistratorWrapper < void, string::LinearString < > > ( StringAccess::access );
+auto StringAccessFormalString = registration::OverloadRegister < StringAccess, void, string::LinearString < > > ( StringAccess::access );
 
 void StringAccess::access ( string::CyclicString < > & string, const StringSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == StringSettings::Settings::ALPHABET )
@@ -47,4 +48,4 @@ void StringAccess::access ( string::CyclicString < > & string, const StringSetti
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto StringAccessUnboundedString = StringAccess::RegistratorWrapper < void, string::CyclicString < > > ( StringAccess::access );
+auto StringAccessUnboundedString = registration::OverloadRegister < StringAccess, void, string::CyclicString < > > ( StringAccess::access );
diff --git a/aaccess2/src/TreeAccess.cpp b/aaccess2/src/TreeAccess.cpp
index 8ae88c879504191e74f68a000fb7e0b26c401611..da006d7dde0d84be09419e2416b09cb134c90460 100644
--- a/aaccess2/src/TreeAccess.cpp
+++ b/aaccess2/src/TreeAccess.cpp
@@ -22,6 +22,7 @@
 #include <container/ObjectsTree.h>
 
 #include "common/AccessHelpers.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 void TreeAccess::access ( tree::Tree & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	dispatch ( tree.getData ( ), settings, operation, argument );
@@ -37,7 +38,7 @@ void TreeAccess::access ( tree::RankedTree < > & tree, const TreeSettings::Setti
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto TreeAccessRankedTree = TreeAccess::RegistratorWrapper < void, tree::RankedTree < > > ( TreeAccess::access );
+auto TreeAccessRankedTree = registration::OverloadRegister < TreeAccess, void, tree::RankedTree < > > ( TreeAccess::access );
 
 void TreeAccess::access ( tree::RankedPattern < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == TreeSettings::Settings::ALPHABET )
@@ -52,7 +53,7 @@ void TreeAccess::access ( tree::RankedPattern < > & tree, const TreeSettings::Se
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto TreeAccessRankedPattern = TreeAccess::RegistratorWrapper < void, tree::RankedPattern < > > ( TreeAccess::access );
+auto TreeAccessRankedPattern = registration::OverloadRegister < TreeAccess, void, tree::RankedPattern < > > ( TreeAccess::access );
 
 void TreeAccess::access ( tree::RankedNonlinearPattern < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == TreeSettings::Settings::ALPHABET )
@@ -70,7 +71,7 @@ void TreeAccess::access ( tree::RankedNonlinearPattern < > & tree, const TreeSet
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto TreeAccessRankedNonlinearPattern = TreeAccess::RegistratorWrapper < void, tree::RankedNonlinearPattern < > > ( TreeAccess::access );
+auto TreeAccessRankedNonlinearPattern = registration::OverloadRegister < TreeAccess, void, tree::RankedNonlinearPattern < > > ( TreeAccess::access );
 
 void TreeAccess::access ( tree::UnrankedTree < > & tree, const TreeSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == TreeSettings::Settings::ALPHABET )
@@ -82,4 +83,4 @@ void TreeAccess::access ( tree::UnrankedTree < > & tree, const TreeSettings::Set
 	throw exception::CommonException ( "Component not available" );
 }
 
-auto TreeAccessUnrankedTree = TreeAccess::RegistratorWrapper < void, tree::UnrankedTree < > > ( TreeAccess::access );
+auto TreeAccessUnrankedTree = registration::OverloadRegister < TreeAccess, void, tree::UnrankedTree < > > ( TreeAccess::access );
diff --git a/acompare2/src/AutomatonCompare.cpp b/acompare2/src/AutomatonCompare.cpp
index f8e49fc265f83bb37f1567d8d21627045efe6141..32c7ae6740b161f2b8539a9b596d3bae141faefb 100644
--- a/acompare2/src/AutomatonCompare.cpp
+++ b/acompare2/src/AutomatonCompare.cpp
@@ -6,29 +6,30 @@
  */
 
 #include "AutomatonCompare.h"
+#include <registration/AlgoRegistration.hpp>
 
-auto AutomatonCompareDFA = AutomatonCompare::RegistratorWrapper<int, automaton::DFA < >, automaton::DFA < > >(AutomatonCompare::compare);
-auto AutomatonCompareNFA = AutomatonCompare::RegistratorWrapper<int, automaton::NFA < > , automaton::NFA < > >(AutomatonCompare::compare);
-auto AutomatonCompareMultiInitialStateNFA = AutomatonCompare::RegistratorWrapper<int, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > >(AutomatonCompare::compare);
-auto AutomatonCompareEpsilonNFA = AutomatonCompare::RegistratorWrapper<int, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(AutomatonCompare::compare);
-auto AutomatonCompareExtendedNFA = AutomatonCompare::RegistratorWrapper<int, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(AutomatonCompare::compare);
-auto AutomatonCompareCompactNFA = AutomatonCompare::RegistratorWrapper<int, automaton::CompactNFA < >, automaton::CompactNFA < > >(AutomatonCompare::compare);
+auto AutomatonCompareDFA = registration::OverloadRegister < AutomatonCompare, int, automaton::DFA < >, automaton::DFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::NFA < > , automaton::NFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareMultiInitialStateNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareEpsilonNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareExtendedNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareCompactNFA = registration::OverloadRegister < AutomatonCompare, int, automaton::CompactNFA < >, automaton::CompactNFA < > > ( AutomatonCompare::compare );
 
-auto AutomatonCompareDFTA = AutomatonCompare::RegistratorWrapper<int, automaton::DFTA < >, automaton::DFTA < > >(AutomatonCompare::compare);
-auto AutomatonCompareNFTA = AutomatonCompare::RegistratorWrapper<int, automaton::NFTA < >, automaton::NFTA < > >(AutomatonCompare::compare);
+auto AutomatonCompareDFTA = registration::OverloadRegister < AutomatonCompare, int, automaton::DFTA < >, automaton::DFTA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNFTA = registration::OverloadRegister < AutomatonCompare, int, automaton::NFTA < >, automaton::NFTA < > > ( AutomatonCompare::compare );
 
-auto AutomatonCompareDPDA = AutomatonCompare::RegistratorWrapper<int, automaton::DPDA < >, automaton::DPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareNPDA = AutomatonCompare::RegistratorWrapper<int, automaton::NPDA < >, automaton::NPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareInputDrivenDPDA = AutomatonCompare::RegistratorWrapper<int, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareInputDrivenNPDA = AutomatonCompare::RegistratorWrapper<int, automaton::InputDrivenNPDA < >, automaton::InputDrivenNPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareVisiblyPushdownDPDA = AutomatonCompare::RegistratorWrapper<int, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareVisiblyPushdownNPDA = AutomatonCompare::RegistratorWrapper<int, automaton::VisiblyPushdownNPDA < >, automaton::VisiblyPushdownNPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareRealTimeHeightDeterministicDPDA = AutomatonCompare::RegistratorWrapper<int, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareRealTimeHeightDeterministicNPDA = AutomatonCompare::RegistratorWrapper<int, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareSinglePopDPDA = AutomatonCompare::RegistratorWrapper<int, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > >(AutomatonCompare::compare);
-auto AutomatonCompareSinglePopNPDA = AutomatonCompare::RegistratorWrapper<int, automaton::SinglePopNPDA < >, automaton::SinglePopNPDA < > >(AutomatonCompare::compare);
+auto AutomatonCompareDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::DPDA < >, automaton::DPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::NPDA < >, automaton::NPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareInputDrivenDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareInputDrivenNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::InputDrivenNPDA < >, automaton::InputDrivenNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareVisiblyPushdownDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareVisiblyPushdownNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::VisiblyPushdownNPDA < >, automaton::VisiblyPushdownNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareRealTimeHeightDeterministicDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareRealTimeHeightDeterministicNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareSinglePopDPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > > ( AutomatonCompare::compare );
+auto AutomatonCompareSinglePopNPDA = registration::OverloadRegister < AutomatonCompare, int, automaton::SinglePopNPDA < >, automaton::SinglePopNPDA < > > ( AutomatonCompare::compare );
 
-auto AutomatonCompareOneTapeDTM = AutomatonCompare::RegistratorWrapper<int, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > >(AutomatonCompare::compare);
+auto AutomatonCompareOneTapeDTM = registration::OverloadRegister < AutomatonCompare, int, automaton::OneTapeDTM < >, automaton::OneTapeDTM < > > ( AutomatonCompare::compare );
 
 int AutomatonCompare::compare(const automaton::Automaton& a, const automaton::Automaton& b) {
 	return dispatch(a.getData(), b.getData());
diff --git a/acompare2/src/GrammarCompare.cpp b/acompare2/src/GrammarCompare.cpp
index 560ba1b3ac7892841ae08fb1cd1eb67db47c1ec7..d279838daf004ddbd9b903531306b02810d16ddf 100644
--- a/acompare2/src/GrammarCompare.cpp
+++ b/acompare2/src/GrammarCompare.cpp
@@ -29,6 +29,7 @@
 #include "grammar/ContextSensitive/NonContractingGrammar.h"
 #include "grammar/Unrestricted/ContextPreservingUnrestrictedGrammar.h"
 #include "grammar/Unrestricted/UnrestrictedGrammar.h"
+#include <registration/AlgoRegistration.hpp>
 
 bool GrammarCompare::testCompare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
@@ -559,22 +560,22 @@ void GrammarCompare::printCompare(const grammar::UnrestrictedGrammar < > & a, co
 	}
 }
 
-auto GrammarCompareLeftLG = GrammarCompare::RegistratorWrapper<int, grammar::LeftLG < >, grammar::LeftLG < > >(GrammarCompare::compare);
-auto GrammarCompareLeftRG = GrammarCompare::RegistratorWrapper<int, grammar::LeftRG < >, grammar::LeftRG < > >(GrammarCompare::compare);
-auto GrammarCompareRightLG = GrammarCompare::RegistratorWrapper<int, grammar::RightLG < >, grammar::RightLG < > >(GrammarCompare::compare);
-auto GrammarCompareRightRG = GrammarCompare::RegistratorWrapper<int, grammar::RightRG < >, grammar::RightRG < > >(GrammarCompare::compare);
+auto GrammarCompareLeftLG = registration::OverloadRegister < GrammarCompare, int, grammar::LeftLG < >, grammar::LeftLG < > > ( GrammarCompare::compare );
+auto GrammarCompareLeftRG = registration::OverloadRegister < GrammarCompare, int, grammar::LeftRG < >, grammar::LeftRG < > > ( GrammarCompare::compare );
+auto GrammarCompareRightLG = registration::OverloadRegister < GrammarCompare, int, grammar::RightLG < >, grammar::RightLG < > > ( GrammarCompare::compare );
+auto GrammarCompareRightRG = registration::OverloadRegister < GrammarCompare, int, grammar::RightRG < >, grammar::RightRG < > > ( GrammarCompare::compare );
 
-auto GrammarCompareLG = GrammarCompare::RegistratorWrapper<int, grammar::LG < >, grammar::LG < > >(GrammarCompare::compare);
-auto GrammarCompareCFG = GrammarCompare::RegistratorWrapper<int, grammar::CFG < >, grammar::CFG < > >(GrammarCompare::compare);
-auto GrammarCompareEpsilonFreeCFG = GrammarCompare::RegistratorWrapper<int, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(GrammarCompare::compare);
-auto GrammarCompareCNF = GrammarCompare::RegistratorWrapper<int, grammar::CNF < >, grammar::CNF < > >(GrammarCompare::compare);
-auto GrammarCompareGNF = GrammarCompare::RegistratorWrapper<int, grammar::GNF < >, grammar::GNF < > >(GrammarCompare::compare);
-auto GrammarCompareCSG = GrammarCompare::RegistratorWrapper<int, grammar::CSG < >, grammar::CSG < > >(GrammarCompare::compare);
+auto GrammarCompareLG = registration::OverloadRegister < GrammarCompare, int, grammar::LG < >, grammar::LG < > > ( GrammarCompare::compare );
+auto GrammarCompareCFG = registration::OverloadRegister < GrammarCompare, int, grammar::CFG < >, grammar::CFG < > > ( GrammarCompare::compare );
+auto GrammarCompareEpsilonFreeCFG = registration::OverloadRegister < GrammarCompare, int, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( GrammarCompare::compare );
+auto GrammarCompareCNF = registration::OverloadRegister < GrammarCompare, int, grammar::CNF < >, grammar::CNF < > > ( GrammarCompare::compare );
+auto GrammarCompareGNF = registration::OverloadRegister < GrammarCompare, int, grammar::GNF < >, grammar::GNF < > > ( GrammarCompare::compare );
+auto GrammarCompareCSG = registration::OverloadRegister < GrammarCompare, int, grammar::CSG < >, grammar::CSG < > > ( GrammarCompare::compare );
 
-auto GrammarCompareNonContractingGrammar = GrammarCompare::RegistratorWrapper<int, grammar::NonContractingGrammar < >, grammar::NonContractingGrammar < > >(GrammarCompare::compare);
-auto GrammarCompareContextPreservingUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::ContextPreservingUnrestrictedGrammar < >, grammar::ContextPreservingUnrestrictedGrammar < > >(GrammarCompare::compare);
+auto GrammarCompareNonContractingGrammar = registration::OverloadRegister < GrammarCompare, int, grammar::NonContractingGrammar < >, grammar::NonContractingGrammar < > > ( GrammarCompare::compare );
+auto GrammarCompareContextPreservingUnrestrictedGrammar = registration::OverloadRegister < GrammarCompare, int, grammar::ContextPreservingUnrestrictedGrammar < >, grammar::ContextPreservingUnrestrictedGrammar < > > ( GrammarCompare::compare );
 
-auto GrammarCompareUnrestrictedGrammar = GrammarCompare::RegistratorWrapper<int, grammar::UnrestrictedGrammar < >, grammar::UnrestrictedGrammar < > >(GrammarCompare::compare);
+auto GrammarCompareUnrestrictedGrammar = registration::OverloadRegister < GrammarCompare, int, grammar::UnrestrictedGrammar < >, grammar::UnrestrictedGrammar < > > ( GrammarCompare::compare );
 
 int GrammarCompare::compare(const grammar::Grammar& a, const grammar::Grammar& b) {
 	return dispatch(a.getData(), b.getData());
diff --git a/acompare2/src/StringCompare.cpp b/acompare2/src/StringCompare.cpp
index 4946e9c3aa7fda4883deb4f55f7108761fad9151..5919a5481ef2a5f2bd4d558f22e5eb707947da44 100644
--- a/acompare2/src/StringCompare.cpp
+++ b/acompare2/src/StringCompare.cpp
@@ -9,6 +9,7 @@
 
 #include "string/CyclicString.h"
 #include "string/LinearString.h"
+#include <registration/AlgoRegistration.hpp>
 
 bool StringCompare::testCompare ( const string::LinearString < > & a, const string::LinearString < > & b ) {
 	return a.getContent ( ) == b.getContent ( ) && a.getAlphabet ( ) == b.getAlphabet ( );
@@ -72,8 +73,8 @@ void StringCompare::printCompare ( const string::LinearString < > & a, const str
 	}
 }
 
-auto StringCompareLinear = StringCompare::RegistratorWrapper < int, string::LinearString < >, string::LinearString < > > ( StringCompare::compare );
-auto StringCompareCyclic = StringCompare::RegistratorWrapper < int, string::CyclicString < >, string::CyclicString < > > ( StringCompare::compare );
+auto StringCompareLinear = registration::OverloadRegister < StringCompare, int, string::LinearString < >, string::LinearString < > > ( StringCompare::compare );
+auto StringCompareCyclic = registration::OverloadRegister < StringCompare, int, string::CyclicString < >, string::CyclicString < > > ( StringCompare::compare );
 
 int StringCompare::compare ( const string::String & a, const string::String & b ) {
 	return dispatch ( a.getData ( ), b.getData ( ) );
diff --git a/aconvert2/src/DotConverter.cpp b/aconvert2/src/DotConverter.cpp
index aa281a9f8842240cb2b338ac56847ec178644a95..e7cb21094c1a2b610302329da9f41e33b15b74d8 100644
--- a/aconvert2/src/DotConverter.cpp
+++ b/aconvert2/src/DotConverter.cpp
@@ -6,28 +6,29 @@
  */
 
 #include "DotConverter.h"
+#include <registration/AlgoRegistration.hpp>
 
 void DotConverter::convert(std::ostream& out, const automaton::Automaton& a) {
 	dispatch(out, a.getData());
 }
 
-auto DotConverterEpsilonNFA = DotConverter::RegistratorWrapper<void, automaton::EpsilonNFA < > >(DotConverter::convert);
-auto DotConverterMultiInitialStateNFA = DotConverter::RegistratorWrapper<void, automaton::MultiInitialStateNFA < >>(DotConverter::convert);
-auto DotConverterNFA = DotConverter::RegistratorWrapper<void, automaton::NFA < > >(DotConverter::convert);
-auto DotConverterDFA = DotConverter::RegistratorWrapper<void, automaton::DFA < > >(DotConverter::convert);
-auto DotConverterExtendedNFA = DotConverter::RegistratorWrapper<void, automaton::ExtendedNFA < > >(DotConverter::convert);
-auto DotConverterCompactNFA = DotConverter::RegistratorWrapper<void, automaton::CompactNFA < > >(DotConverter::convert);
-auto DotConverterNFTA = DotConverter::RegistratorWrapper<void, automaton::NFTA < > >(DotConverter::convert);
-auto DotConverterDFTA = DotConverter::RegistratorWrapper<void, automaton::DFTA < > >(DotConverter::convert);
-auto DotConverterDPDA = DotConverter::RegistratorWrapper<void, automaton::DPDA < > >(DotConverter::convert);
-auto DotConverterSinglePopDPDA = DotConverter::RegistratorWrapper<void, automaton::SinglePopDPDA < > >(DotConverter::convert);
-auto DotConverterInputDrivenDPDA = DotConverter::RegistratorWrapper<void, automaton::InputDrivenDPDA < > >(DotConverter::convert);
-auto DotConverterInputDrivenNPDA = DotConverter::RegistratorWrapper<void, automaton::InputDrivenNPDA < > >(DotConverter::convert);
-auto DotConverterVisiblyPushdownDPDA = DotConverter::RegistratorWrapper<void, automaton::VisiblyPushdownDPDA < > >(DotConverter::convert);
-auto DotConverterVisiblyPushdownNPDA = DotConverter::RegistratorWrapper<void, automaton::VisiblyPushdownNPDA < > >(DotConverter::convert);
-auto DotConverterRealTimeHeightDeterministicDPDA = DotConverter::RegistratorWrapper<void, automaton::RealTimeHeightDeterministicDPDA < > >(DotConverter::convert);
-auto DotConverterRealTimeHeightDeterministicNPDA = DotConverter::RegistratorWrapper<void, automaton::RealTimeHeightDeterministicNPDA < > >(DotConverter::convert);
-auto DotConverterNPDA = DotConverter::RegistratorWrapper<void, automaton::NPDA < > >(DotConverter::convert);
-auto DotConverterSinglePopNPDA = DotConverter::RegistratorWrapper<void, automaton::SinglePopNPDA < > >(DotConverter::convert);
-auto DotConverterOneTapeDTM = DotConverter::RegistratorWrapper<void, automaton::OneTapeDTM < > >(DotConverter::convert);
+auto DotConverterEpsilonNFA = registration::OverloadRegister < DotConverter, void, automaton::EpsilonNFA < > > ( DotConverter::convert );
+auto DotConverterMultiInitialStateNFA = registration::OverloadRegister < DotConverter, void, automaton::MultiInitialStateNFA < >> ( DotConverter::convert );
+auto DotConverterNFA = registration::OverloadRegister < DotConverter, void, automaton::NFA < > > ( DotConverter::convert );
+auto DotConverterDFA = registration::OverloadRegister < DotConverter, void, automaton::DFA < > > ( DotConverter::convert );
+auto DotConverterExtendedNFA = registration::OverloadRegister < DotConverter, void, automaton::ExtendedNFA < > > ( DotConverter::convert );
+auto DotConverterCompactNFA = registration::OverloadRegister < DotConverter, void, automaton::CompactNFA < > > ( DotConverter::convert );
+auto DotConverterNFTA = registration::OverloadRegister < DotConverter, void, automaton::NFTA < > > ( DotConverter::convert );
+auto DotConverterDFTA = registration::OverloadRegister < DotConverter, void, automaton::DFTA < > > ( DotConverter::convert );
+auto DotConverterDPDA = registration::OverloadRegister < DotConverter, void, automaton::DPDA < > > ( DotConverter::convert );
+auto DotConverterSinglePopDPDA = registration::OverloadRegister < DotConverter, void, automaton::SinglePopDPDA < > > ( DotConverter::convert );
+auto DotConverterInputDrivenDPDA = registration::OverloadRegister < DotConverter, void, automaton::InputDrivenDPDA < > > ( DotConverter::convert );
+auto DotConverterInputDrivenNPDA = registration::OverloadRegister < DotConverter, void, automaton::InputDrivenNPDA < > > ( DotConverter::convert );
+auto DotConverterVisiblyPushdownDPDA = registration::OverloadRegister < DotConverter, void, automaton::VisiblyPushdownDPDA < > > ( DotConverter::convert );
+auto DotConverterVisiblyPushdownNPDA = registration::OverloadRegister < DotConverter, void, automaton::VisiblyPushdownNPDA < > > ( DotConverter::convert );
+auto DotConverterRealTimeHeightDeterministicDPDA = registration::OverloadRegister < DotConverter, void, automaton::RealTimeHeightDeterministicDPDA < > > ( DotConverter::convert );
+auto DotConverterRealTimeHeightDeterministicNPDA = registration::OverloadRegister < DotConverter, void, automaton::RealTimeHeightDeterministicNPDA < > > ( DotConverter::convert );
+auto DotConverterNPDA = registration::OverloadRegister < DotConverter, void, automaton::NPDA < > > ( DotConverter::convert );
+auto DotConverterSinglePopNPDA = registration::OverloadRegister < DotConverter, void, automaton::SinglePopNPDA < > > ( DotConverter::convert );
+auto DotConverterOneTapeDTM = registration::OverloadRegister < DotConverter, void, automaton::OneTapeDTM < > > ( DotConverter::convert );
 
diff --git a/aconvert2/src/GasTexConverter.cpp b/aconvert2/src/GasTexConverter.cpp
index e9845d297b7dacfa745f30a6b0784901b56c710a..7c19576782b0d1561f4ceec9201b9c36cd9c4528 100644
--- a/aconvert2/src/GasTexConverter.cpp
+++ b/aconvert2/src/GasTexConverter.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "GasTexConverter.h"
+#include <registration/AlgoRegistration.hpp>
 
 void GasTexConverter::printTransitionMap(const std::map<std::pair<std::string, std::string>, std::string> transitionMap, std::ostream& out) {
 	for (const auto& transition : transitionMap) {
@@ -36,23 +37,23 @@ void GasTexConverter::convert(std::ostream& out, const automaton::Automaton& a)
 	dispatch(out, a.getData());
 }
 
-auto GasTexConverterEpsilonNFA = GasTexConverter::RegistratorWrapper<void, automaton::EpsilonNFA < > >(GasTexConverter::convert);
-auto GasTexConverterMultiInitialStateNFA = GasTexConverter::RegistratorWrapper<void, automaton::MultiInitialStateNFA < > >(GasTexConverter::convert);
-auto GasTexConverterNFA = GasTexConverter::RegistratorWrapper<void, automaton::NFA < > >(GasTexConverter::convert);
-auto GasTexConverterDFA = GasTexConverter::RegistratorWrapper<void, automaton::DFA < > >(GasTexConverter::convert);
-auto GasTexConverterExtendedNFA = GasTexConverter::RegistratorWrapper<void, automaton::ExtendedNFA < > >(GasTexConverter::convert);
-auto GasTexConverterCompactNFA = GasTexConverter::RegistratorWrapper<void, automaton::CompactNFA < > >(GasTexConverter::convert);
-auto GasTexConverterNFTA = GasTexConverter::RegistratorWrapper<void, automaton::NFTA < > >(GasTexConverter::convert);
-auto GasTexConverterDFTA = GasTexConverter::RegistratorWrapper<void, automaton::DFTA < > >(GasTexConverter::convert);
-auto GasTexConverterDPDA = GasTexConverter::RegistratorWrapper<void, automaton::DPDA < > >(GasTexConverter::convert);
-auto GasTexConverterSinglePopDPDA = GasTexConverter::RegistratorWrapper<void, automaton::SinglePopDPDA < > >(GasTexConverter::convert);
-auto GasTexConverterInputDrivenDPDA = GasTexConverter::RegistratorWrapper<void, automaton::InputDrivenDPDA < > >(GasTexConverter::convert);
-auto GasTexConverterInputDrivenNPDA = GasTexConverter::RegistratorWrapper<void, automaton::InputDrivenNPDA < > >(GasTexConverter::convert);
-auto GasTexConverterVisiblyPushdownDPDA = GasTexConverter::RegistratorWrapper<void, automaton::VisiblyPushdownDPDA < > >(GasTexConverter::convert);
-auto GasTexConverterVisiblyPushdownNPDA = GasTexConverter::RegistratorWrapper<void, automaton::VisiblyPushdownNPDA < > >(GasTexConverter::convert);
-auto GasTexConverterRealTimeHeightDeterministicDPDA = GasTexConverter::RegistratorWrapper<void, automaton::RealTimeHeightDeterministicDPDA < > >(GasTexConverter::convert);
-auto GasTexConverterRealTimeHeightDeterministicNPDA = GasTexConverter::RegistratorWrapper<void, automaton::RealTimeHeightDeterministicNPDA < > >(GasTexConverter::convert);
-auto GasTexConverterNPDA = GasTexConverter::RegistratorWrapper<void, automaton::NPDA < > >(GasTexConverter::convert);
-auto GasTexConverterSinglePopNPDA = GasTexConverter::RegistratorWrapper<void, automaton::SinglePopNPDA < > >(GasTexConverter::convert);
-auto GasTexConverterOneTapeDTM = GasTexConverter::RegistratorWrapper<void, automaton::OneTapeDTM < > >(GasTexConverter::convert);
+auto GasTexConverterEpsilonNFA = registration::OverloadRegister < GasTexConverter, void, automaton::EpsilonNFA < > > ( GasTexConverter::convert );
+auto GasTexConverterMultiInitialStateNFA = registration::OverloadRegister < GasTexConverter, void, automaton::MultiInitialStateNFA < > > ( GasTexConverter::convert );
+auto GasTexConverterNFA = registration::OverloadRegister < GasTexConverter, void, automaton::NFA < > > ( GasTexConverter::convert );
+auto GasTexConverterDFA = registration::OverloadRegister < GasTexConverter, void, automaton::DFA < > > ( GasTexConverter::convert );
+auto GasTexConverterExtendedNFA = registration::OverloadRegister < GasTexConverter, void, automaton::ExtendedNFA < > > ( GasTexConverter::convert );
+auto GasTexConverterCompactNFA = registration::OverloadRegister < GasTexConverter, void, automaton::CompactNFA < > > ( GasTexConverter::convert );
+auto GasTexConverterNFTA = registration::OverloadRegister < GasTexConverter, void, automaton::NFTA < > > ( GasTexConverter::convert );
+auto GasTexConverterDFTA = registration::OverloadRegister < GasTexConverter, void, automaton::DFTA < > > ( GasTexConverter::convert );
+auto GasTexConverterDPDA = registration::OverloadRegister < GasTexConverter, void, automaton::DPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterSinglePopDPDA = registration::OverloadRegister < GasTexConverter, void, automaton::SinglePopDPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterInputDrivenDPDA = registration::OverloadRegister < GasTexConverter, void, automaton::InputDrivenDPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterInputDrivenNPDA = registration::OverloadRegister < GasTexConverter, void, automaton::InputDrivenNPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterVisiblyPushdownDPDA = registration::OverloadRegister < GasTexConverter, void, automaton::VisiblyPushdownDPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterVisiblyPushdownNPDA = registration::OverloadRegister < GasTexConverter, void, automaton::VisiblyPushdownNPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterRealTimeHeightDeterministicDPDA = registration::OverloadRegister < GasTexConverter, void, automaton::RealTimeHeightDeterministicDPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterRealTimeHeightDeterministicNPDA = registration::OverloadRegister < GasTexConverter, void, automaton::RealTimeHeightDeterministicNPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterNPDA = registration::OverloadRegister < GasTexConverter, void, automaton::NPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterSinglePopNPDA = registration::OverloadRegister < GasTexConverter, void, automaton::SinglePopNPDA < > > ( GasTexConverter::convert );
+auto GasTexConverterOneTapeDTM = registration::OverloadRegister < GasTexConverter, void, automaton::OneTapeDTM < > > ( GasTexConverter::convert );
 
diff --git a/aconvert2/src/TikZConverter.cpp b/aconvert2/src/TikZConverter.cpp
index b283e06dff35ec6f51272cdb6b2b6f66fba49f72..f379a53e7fa7bbd357bac62c18eb535bc28e1970 100644
--- a/aconvert2/src/TikZConverter.cpp
+++ b/aconvert2/src/TikZConverter.cpp
@@ -6,28 +6,29 @@
  */
 
 #include "TikZConverter.h"
+#include <registration/AlgoRegistration.hpp>
 
 void TikZConverter::convert ( std::ostream & out, const automaton::Automaton & a ) {
 	dispatch ( out, a.getData ( ) );
 }
 
-auto TikZConverterEpsilonNFA = TikZConverter::RegistratorWrapper < void, automaton::EpsilonNFA < > > ( TikZConverter::convert );
-auto TikZConverterMultiInitialStateNFA = TikZConverter::RegistratorWrapper < void, automaton::MultiInitialStateNFA < > > ( TikZConverter::convert );
-auto TikZConverterNFA = TikZConverter::RegistratorWrapper < void, automaton::NFA < > > ( TikZConverter::convert );
-auto TikZConverterDFA = TikZConverter::RegistratorWrapper < void, automaton::DFA < > > ( TikZConverter::convert );
-auto TikZConverterExtendedNFA = TikZConverter::RegistratorWrapper < void, automaton::ExtendedNFA < > > ( TikZConverter::convert );
-auto TikZConverterCompactNFA = TikZConverter::RegistratorWrapper < void, automaton::CompactNFA < > > ( TikZConverter::convert );
-auto TikZConverterNFTA = TikZConverter::RegistratorWrapper < void, automaton::NFTA < > > ( TikZConverter::convert );
-auto TikZConverterDFTA = TikZConverter::RegistratorWrapper < void, automaton::DFTA < > > ( TikZConverter::convert );
-auto TikZConverterDPDA = TikZConverter::RegistratorWrapper < void, automaton::DPDA < > > ( TikZConverter::convert );
-auto TikZConverterSinglePopDPDA = TikZConverter::RegistratorWrapper < void, automaton::SinglePopDPDA < > > ( TikZConverter::convert );
-auto TikZConverterInputDrivenDPDA = TikZConverter::RegistratorWrapper < void, automaton::InputDrivenDPDA < > > ( TikZConverter::convert );
-auto TikZConverterInputDrivenNPDA = TikZConverter::RegistratorWrapper < void, automaton::InputDrivenNPDA < > > ( TikZConverter::convert );
-auto TikZConverterVisiblyPushdownDPDA = TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownDPDA < > > ( TikZConverter::convert );
-auto TikZConverterVisiblyPushdownNPDA = TikZConverter::RegistratorWrapper < void, automaton::VisiblyPushdownNPDA < > > ( TikZConverter::convert );
-auto TikZConverterRealTimeHeightDeterministicDPDA = TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicDPDA < > > ( TikZConverter::convert );
-auto TikZConverterRealTimeHeightDeterministicNPDA = TikZConverter::RegistratorWrapper < void, automaton::RealTimeHeightDeterministicNPDA < > > ( TikZConverter::convert );
-auto TikZConverterNPDA = TikZConverter::RegistratorWrapper < void, automaton::NPDA < > > ( TikZConverter::convert );
-auto TikZConverterSinglePopNPDA = TikZConverter::RegistratorWrapper < void, automaton::SinglePopNPDA < > > ( TikZConverter::convert );
-auto TikZConverterOneTapeDTM = TikZConverter::RegistratorWrapper < void, automaton::OneTapeDTM < > > ( TikZConverter::convert );
+auto TikZConverterEpsilonNFA = registration::OverloadRegister < TikZConverter, void, automaton::EpsilonNFA < > > ( TikZConverter::convert );
+auto TikZConverterMultiInitialStateNFA = registration::OverloadRegister < TikZConverter, void, automaton::MultiInitialStateNFA < > > ( TikZConverter::convert );
+auto TikZConverterNFA = registration::OverloadRegister < TikZConverter, void, automaton::NFA < > > ( TikZConverter::convert );
+auto TikZConverterDFA = registration::OverloadRegister < TikZConverter, void, automaton::DFA < > > ( TikZConverter::convert );
+auto TikZConverterExtendedNFA = registration::OverloadRegister < TikZConverter, void, automaton::ExtendedNFA < > > ( TikZConverter::convert );
+auto TikZConverterCompactNFA = registration::OverloadRegister < TikZConverter, void, automaton::CompactNFA < > > ( TikZConverter::convert );
+auto TikZConverterNFTA = registration::OverloadRegister < TikZConverter, void, automaton::NFTA < > > ( TikZConverter::convert );
+auto TikZConverterDFTA = registration::OverloadRegister < TikZConverter, void, automaton::DFTA < > > ( TikZConverter::convert );
+auto TikZConverterDPDA = registration::OverloadRegister < TikZConverter, void, automaton::DPDA < > > ( TikZConverter::convert );
+auto TikZConverterSinglePopDPDA = registration::OverloadRegister < TikZConverter, void, automaton::SinglePopDPDA < > > ( TikZConverter::convert );
+auto TikZConverterInputDrivenDPDA = registration::OverloadRegister < TikZConverter, void, automaton::InputDrivenDPDA < > > ( TikZConverter::convert );
+auto TikZConverterInputDrivenNPDA = registration::OverloadRegister < TikZConverter, void, automaton::InputDrivenNPDA < > > ( TikZConverter::convert );
+auto TikZConverterVisiblyPushdownDPDA = registration::OverloadRegister < TikZConverter, void, automaton::VisiblyPushdownDPDA < > > ( TikZConverter::convert );
+auto TikZConverterVisiblyPushdownNPDA = registration::OverloadRegister < TikZConverter, void, automaton::VisiblyPushdownNPDA < > > ( TikZConverter::convert );
+auto TikZConverterRealTimeHeightDeterministicDPDA = registration::OverloadRegister < TikZConverter, void, automaton::RealTimeHeightDeterministicDPDA < > > ( TikZConverter::convert );
+auto TikZConverterRealTimeHeightDeterministicNPDA = registration::OverloadRegister < TikZConverter, void, automaton::RealTimeHeightDeterministicNPDA < > > ( TikZConverter::convert );
+auto TikZConverterNPDA = registration::OverloadRegister < TikZConverter, void, automaton::NPDA < > > ( TikZConverter::convert );
+auto TikZConverterSinglePopNPDA = registration::OverloadRegister < TikZConverter, void, automaton::SinglePopNPDA < > > ( TikZConverter::convert );
+auto TikZConverterOneTapeDTM = registration::OverloadRegister < TikZConverter, void, automaton::OneTapeDTM < > > ( TikZConverter::convert );
 
diff --git a/alib2algo/src/arbology/exact/BoyerMooreHorspool.cpp b/alib2algo/src/arbology/exact/BoyerMooreHorspool.cpp
index d31d1e892b8f62b658f71b1e6055599a42d858c0..1640c25357e6bb2680864b4222a4150b89c10aab 100644
--- a/alib2algo/src/arbology/exact/BoyerMooreHorspool.cpp
+++ b/alib2algo/src/arbology/exact/BoyerMooreHorspool.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BoyerMooreHorspool.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,9 +16,9 @@ std::set < unsigned > BoyerMooreHorspool::match ( const tree::Tree & subject, co
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarTree = BoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( BoyerMooreHorspool::match );
-auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarPattern = BoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( BoyerMooreHorspool::match );
-auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarNonlinearPattern = BoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( BoyerMooreHorspool::match );
+auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarTree = registration::OverloadRegister < BoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( BoyerMooreHorspool::match );
+auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarPattern = registration::OverloadRegister < BoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( BoyerMooreHorspool::match );
+auto BoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarNonlinearPattern = registration::OverloadRegister < BoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( BoyerMooreHorspool::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/DeadZoneUsingBadCharacterShiftAndBorderArray.cpp b/alib2algo/src/arbology/exact/DeadZoneUsingBadCharacterShiftAndBorderArray.cpp
index 8ef1994b84c9efbde74712b254774bcb137b99b2..349e93c4d88880cd81530426fe71929118dfc548 100644
--- a/alib2algo/src/arbology/exact/DeadZoneUsingBadCharacterShiftAndBorderArray.cpp
+++ b/alib2algo/src/arbology/exact/DeadZoneUsingBadCharacterShiftAndBorderArray.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "DeadZoneUsingBadCharacterShiftAndBorderArray.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,10 +16,10 @@ std::set < unsigned > DeadZoneUsingBadCharacterShiftAndBorderArray::match ( cons
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedBarTreePrefixRankedBarTree = DeadZoneUsingBadCharacterShiftAndBorderArray::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
-auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedBarTreePrefixRankedBarPattern = DeadZoneUsingBadCharacterShiftAndBorderArray::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
-auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedTreePrefixRankedTree = DeadZoneUsingBadCharacterShiftAndBorderArray::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
-auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedTreePrefixRankedPattern = DeadZoneUsingBadCharacterShiftAndBorderArray::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
+auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedBarTreePrefixRankedBarTree = registration::OverloadRegister < DeadZoneUsingBadCharacterShiftAndBorderArray, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
+auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedBarTreePrefixRankedBarPattern = registration::OverloadRegister < DeadZoneUsingBadCharacterShiftAndBorderArray, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
+auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedTreePrefixRankedTree = registration::OverloadRegister < DeadZoneUsingBadCharacterShiftAndBorderArray, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
+auto DeadZoneUsingBadCharacterShiftAndBorderArrayPrefixRankedTreePrefixRankedPattern = registration::OverloadRegister < DeadZoneUsingBadCharacterShiftAndBorderArray, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( DeadZoneUsingBadCharacterShiftAndBorderArray::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactNonlinearTreePatternAutomaton.cpp b/alib2algo/src/arbology/exact/ExactNonlinearTreePatternAutomaton.cpp
index 28649b9ca6c3a2a3bb254547e1ac9b8d83ee9536..b27ef0ab7ce186a5fecdab3fd7a5d17a656a4a82 100644
--- a/alib2algo/src/arbology/exact/ExactNonlinearTreePatternAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactNonlinearTreePatternAutomaton.cpp
@@ -15,6 +15,7 @@
 
 #include <deque>
 #include <alphabet/RankedSymbol.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -128,7 +129,7 @@ automaton::InputDrivenNPDA < > ExactNonlinearTreePatternAutomaton::construct ( c
 	return constructInternal ( tree, subtreeWildcard, * nonlinearVariables.begin ( ), nonlinearVariables );
 }
 
-auto ExactNonlinearTreePatternAutomatonPrefixRankedTree = ExactNonlinearTreePatternAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactNonlinearTreePatternAutomaton::construct );
+auto ExactNonlinearTreePatternAutomatonPrefixRankedTree = registration::OverloadRegister < ExactNonlinearTreePatternAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactNonlinearTreePatternAutomaton::construct );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
index bbb2ebdeadc8e0e57a114fa87afc8d0c9144d586..d6bfa10251c90f505253b264b482e870fa18720a 100644
--- a/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactPatternMatch.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ExactPatternMatch.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,13 +16,13 @@ std::set < unsigned > ExactPatternMatch::match ( const tree::Tree & subject, con
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto ExactPatternMatchUnrankedPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::UnrankedTree < >, tree::UnrankedPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchRankedPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < >, tree::RankedPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchRankedNonlinearPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < >, tree::RankedNonlinearPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchPrefixRankedPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchPrefixRankedNonlinearPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedNonlinearPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchPrefixRankedBarPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( ExactPatternMatch::match );
-auto ExactPatternMatchPrefixRankedBarNonlinearPattern = ExactPatternMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchUnrankedPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::UnrankedTree < >, tree::UnrankedPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchRankedPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::RankedTree < >, tree::RankedPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchRankedNonlinearPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::RankedTree < >, tree::RankedNonlinearPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchPrefixRankedPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchPrefixRankedNonlinearPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedNonlinearPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchPrefixRankedBarPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( ExactPatternMatch::match );
+auto ExactPatternMatchPrefixRankedBarNonlinearPattern = registration::OverloadRegister < ExactPatternMatch, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( ExactPatternMatch::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactPatternMatchingAutomaton.cpp b/alib2algo/src/arbology/exact/ExactPatternMatchingAutomaton.cpp
index b8cd01309055a3c7d394df7d82b0c2e94bf53e77..869dd5b68f368b82315ec0906632ce8a669a404e 100644
--- a/alib2algo/src/arbology/exact/ExactPatternMatchingAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactPatternMatchingAutomaton.cpp
@@ -25,6 +25,7 @@
 
 #include <deque>
 #include <alphabet/RankedSymbol.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -38,7 +39,7 @@ automaton::InputDrivenNPDA < > ExactPatternMatchingAutomaton::construct ( const
 	return ExactSubtreeMatchingAutomaton::construct ( pattern );
 }
 
-auto ExactPatternMatchingAutomatonPrefixRankedTree = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonPrefixRankedTree = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactPatternMatchingAutomaton::construct );
 
 std::vector < DefaultSymbolType > computeRHS ( const tree::PrefixRankedPattern < > & pattern, const std::vector < int > & patternSubtreeJumpTable, int i ) {
 	const std::vector < std::ranked_symbol < > > & content = pattern.getContent ( );
@@ -114,13 +115,13 @@ automaton::NPDA < > ExactPatternMatchingAutomaton::construct ( const tree::Prefi
 	return res;
 }
 
-auto ExactPatternMatchingAutomatonPrefixRankedPattern = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::NPDA < >, tree::PrefixRankedPattern < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonPrefixRankedPattern = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::NPDA < >, tree::PrefixRankedPattern < > > ( ExactPatternMatchingAutomaton::construct );
 
 automaton::InputDrivenNPDA < > ExactPatternMatchingAutomaton::construct ( const tree::PrefixRankedBarTree < > & pattern ) {
 	return ExactSubtreeMatchingAutomaton::construct ( pattern );
 }
 
-auto ExactPatternMatchingAutomatonPrefixRankedBarTree = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedBarTree < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonPrefixRankedBarTree = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedBarTree < > > ( ExactPatternMatchingAutomaton::construct );
 
 automaton::VisiblyPushdownNPDA < > ExactPatternMatchingAutomaton::construct ( const tree::PrefixRankedBarPattern < > & pattern ) {
 	automaton::VisiblyPushdownNPDA < > res ( alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
@@ -187,13 +188,13 @@ automaton::VisiblyPushdownNPDA < > ExactPatternMatchingAutomaton::construct ( co
 	return res;
 }
 
-auto ExactPatternMatchingAutomatonPrefixRankedBarPattern = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::VisiblyPushdownNPDA < >, tree::PrefixRankedBarPattern < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonPrefixRankedBarPattern = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::VisiblyPushdownNPDA < >, tree::PrefixRankedBarPattern < > > ( ExactPatternMatchingAutomaton::construct );
 
 automaton::NFTA < > ExactPatternMatchingAutomaton::construct ( const tree::RankedTree < > & pattern ) {
 	return ExactSubtreeMatchingAutomaton::construct ( pattern );
 }
 
-auto ExactPatternMatchingAutomatonRankedTree = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::NFTA < >, tree::RankedTree < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonRankedTree = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::NFTA < >, tree::RankedTree < > > ( ExactPatternMatchingAutomaton::construct );
 
 DefaultStateType constructRecursivePattern ( const std::tree < std::ranked_symbol < > > & node, automaton::NFTA < > & res, const std::ranked_symbol < > & subtreeWildcard, const DefaultStateType & loopState, int & nextState ) {
 	if ( node.getData ( ) == subtreeWildcard ) {
@@ -252,7 +253,7 @@ automaton::NFTA < > ExactPatternMatchingAutomaton::construct ( const tree::Ranke
 	return res;
 }
 
-auto ExactPatternMatchingAutomatonRankedPattern = ExactPatternMatchingAutomaton::RegistratorWrapper < automaton::NFTA < >, tree::RankedPattern < > > ( ExactPatternMatchingAutomaton::construct );
+auto ExactPatternMatchingAutomatonRankedPattern = registration::OverloadRegister < ExactPatternMatchingAutomaton, automaton::NFTA < >, tree::RankedPattern < > > ( ExactPatternMatchingAutomaton::construct );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeAutomaton.cpp b/alib2algo/src/arbology/exact/ExactSubtreeAutomaton.cpp
index d6e8ff4c6b0f55c6c20d4a8e76b6d5f5a5f360e9..afb93c4964fb69b6aedf4e742031a2995203de68 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeAutomaton.cpp
@@ -13,6 +13,7 @@
 #include <alphabet/RankedSymbol.h>
 
 #include <deque>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -46,7 +47,7 @@ automaton::InputDrivenNPDA < > ExactSubtreeAutomaton::construct ( const tree::Pr
 	return res;
 }
 
-auto ExactSubtreeAutomatonPrefixRankedTree = ExactSubtreeAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactSubtreeAutomaton::construct );
+auto ExactSubtreeAutomatonPrefixRankedTree = registration::OverloadRegister < ExactSubtreeAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactSubtreeAutomaton::construct );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
index 22d0f0bcfda77076f9c2a0eecb3a67e0a3a300e7..cf35207beb5c68d878cdff77b8291d593f730731 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatch.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ExactSubtreeMatch.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,10 +16,10 @@ std::set < unsigned > ExactSubtreeMatch::match ( const tree::Tree & subject, con
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto ExactSubtreeMatchUnrankedTree = ExactSubtreeMatch::RegistratorWrapper < std::set < unsigned >, tree::UnrankedTree < > > ( ExactSubtreeMatch::match );
-auto ExactSubtreeMatchRankedTree = ExactSubtreeMatch::RegistratorWrapper < std::set < unsigned >, tree::RankedTree < > > ( ExactSubtreeMatch::match );
-auto ExactSubtreeMatchPrefixRankedTree = ExactSubtreeMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < > > ( ExactSubtreeMatch::match );
-auto ExactSubtreeMatchPrefixRankedBarTree = ExactSubtreeMatch::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < > > ( ExactSubtreeMatch::match );
+auto ExactSubtreeMatchUnrankedTree = registration::OverloadRegister < ExactSubtreeMatch, std::set < unsigned >, tree::UnrankedTree < > > ( ExactSubtreeMatch::match );
+auto ExactSubtreeMatchRankedTree = registration::OverloadRegister < ExactSubtreeMatch, std::set < unsigned >, tree::RankedTree < > > ( ExactSubtreeMatch::match );
+auto ExactSubtreeMatchPrefixRankedTree = registration::OverloadRegister < ExactSubtreeMatch, std::set < unsigned >, tree::PrefixRankedTree < > > ( ExactSubtreeMatch::match );
+auto ExactSubtreeMatchPrefixRankedBarTree = registration::OverloadRegister < ExactSubtreeMatch, std::set < unsigned >, tree::PrefixRankedBarTree < > > ( ExactSubtreeMatch::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
index 58756dc27269051af62a01fa596a3f0388ae9a4a..28de78f9d50cbee9b19f9a0db97dba4a5c6aedf1 100644
--- a/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactSubtreeMatchingAutomaton.cpp
@@ -16,6 +16,7 @@
 #include <alphabet/BottomOfTheStackSymbol.h>
 
 #include <deque>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -49,7 +50,7 @@ automaton::InputDrivenNPDA < > ExactSubtreeMatchingAutomaton::construct ( const
 	return res;
 }
 
-auto ExactSubtreeMatchingAutomatonPrefixRankedTree = ExactSubtreeMatchingAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactSubtreeMatchingAutomaton::construct );
+auto ExactSubtreeMatchingAutomatonPrefixRankedTree = registration::OverloadRegister < ExactSubtreeMatchingAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactSubtreeMatchingAutomaton::construct );
 
 automaton::InputDrivenNPDA < > ExactSubtreeMatchingAutomaton::construct ( const tree::PrefixRankedBarTree < > & pattern ) {
 	automaton::InputDrivenNPDA < > res ( DefaultStateType ( 0 ), alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
@@ -81,7 +82,7 @@ automaton::InputDrivenNPDA < > ExactSubtreeMatchingAutomaton::construct ( const
 	return res;
 }
 
-auto ExactSubtreeMatchingAutomatonPrefixRankedBarTree = ExactSubtreeMatchingAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedBarTree < > > ( ExactSubtreeMatchingAutomaton::construct );
+auto ExactSubtreeMatchingAutomatonPrefixRankedBarTree = registration::OverloadRegister < ExactSubtreeMatchingAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedBarTree < > > ( ExactSubtreeMatchingAutomaton::construct );
 
 DefaultStateType constructRecursive ( const std::tree < std::ranked_symbol < > > & node, automaton::NFTA < > & res, int & nextState ) {
 	std::vector < DefaultStateType > states;
@@ -106,7 +107,7 @@ automaton::NFTA < > ExactSubtreeMatchingAutomaton::construct ( const tree::Ranke
 	return res;
 }
 
-auto ExactSubtreeMatchingAutomatonRankedTree = ExactSubtreeMatchingAutomaton::RegistratorWrapper < automaton::NFTA < >, tree::RankedTree < > > ( ExactSubtreeMatchingAutomaton::construct );
+auto ExactSubtreeMatchingAutomatonRankedTree = registration::OverloadRegister < ExactSubtreeMatchingAutomaton, automaton::NFTA < >, tree::RankedTree < > > ( ExactSubtreeMatchingAutomaton::construct );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ExactTreePatternAutomaton.cpp b/alib2algo/src/arbology/exact/ExactTreePatternAutomaton.cpp
index be08b6bc0796811f8139b8a046777656a0bec052..9771dd8a36964211eb60a38bc0555315c9be2e8e 100644
--- a/alib2algo/src/arbology/exact/ExactTreePatternAutomaton.cpp
+++ b/alib2algo/src/arbology/exact/ExactTreePatternAutomaton.cpp
@@ -13,6 +13,7 @@
 #include <automaton/PDA/InputDrivenNPDA.h>
 
 #include <deque>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -59,7 +60,7 @@ automaton::InputDrivenNPDA < > ExactTreePatternAutomaton::construct ( const tree
 	return res;
 }
 
-auto ExactTreePatternAutomatonPrefixRankedTree = ExactTreePatternAutomaton::RegistratorWrapper < automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactTreePatternAutomaton::construct );
+auto ExactTreePatternAutomatonPrefixRankedTree = registration::OverloadRegister < ExactTreePatternAutomaton, automaton::InputDrivenNPDA < >, tree::PrefixRankedTree < > > ( ExactTreePatternAutomaton::construct );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/KnuthMorrisPratt.cpp b/alib2algo/src/arbology/exact/KnuthMorrisPratt.cpp
index 8810d779564d7a0c0af37c277094eb7a291bf400..8ac67d5dade6a4014203417cb17df937e8b2bda9 100644
--- a/alib2algo/src/arbology/exact/KnuthMorrisPratt.cpp
+++ b/alib2algo/src/arbology/exact/KnuthMorrisPratt.cpp
@@ -16,6 +16,7 @@
 #include <tree/ranked/PrefixRankedPattern.h>
 
 #include <map>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -29,7 +30,7 @@ std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedBarTree
 	return match ( subject, tree::PrefixRankedBarPattern < > ( pattern ) );
 }
 
-auto KnuthMorrisPrattPrefixRankedBarTreePrefixRankedBarTree = KnuthMorrisPratt::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( KnuthMorrisPratt::match );
+auto KnuthMorrisPrattPrefixRankedBarTreePrefixRankedBarTree = registration::OverloadRegister < KnuthMorrisPratt, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( KnuthMorrisPratt::match );
 
 std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedBarTree < > & subject, const tree::PrefixRankedBarPattern < > & pattern ) {
 	std::set < unsigned > occ;
@@ -72,13 +73,13 @@ std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedBarTree
 	return occ;
 }
 
-auto KnuthMorrisPrattPrefixRankedBarTreePrefixRankedBarPattern = KnuthMorrisPratt::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( KnuthMorrisPratt::match );
+auto KnuthMorrisPrattPrefixRankedBarTreePrefixRankedBarPattern = registration::OverloadRegister < KnuthMorrisPratt, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( KnuthMorrisPratt::match );
 
 std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedTree < > & subject, const tree::PrefixRankedTree < > & pattern ) {
 	return match ( subject, tree::PrefixRankedPattern < > ( pattern ) );
 }
 
-auto KnuthMorrisPrattPrefixRankedTreePrefixRankedTree = KnuthMorrisPratt::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( KnuthMorrisPratt::match );
+auto KnuthMorrisPrattPrefixRankedTreePrefixRankedTree = registration::OverloadRegister < KnuthMorrisPratt, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( KnuthMorrisPratt::match );
 
 std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedTree < > & subject, const tree::PrefixRankedPattern < > & pattern ) {
 	std::set < unsigned > occ;
@@ -121,7 +122,7 @@ std::set < unsigned > KnuthMorrisPratt::match ( const tree::PrefixRankedTree < >
 	return occ;
 }
 
-auto KnuthMorrisPrattPrefixRankedTreePrefixRankedPattern = KnuthMorrisPratt::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( KnuthMorrisPratt::match );
+auto KnuthMorrisPrattPrefixRankedTreePrefixRankedPattern = registration::OverloadRegister < KnuthMorrisPratt, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( KnuthMorrisPratt::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/exact/ReversedBoyerMooreHorspool.cpp b/alib2algo/src/arbology/exact/ReversedBoyerMooreHorspool.cpp
index 8535cf85619a3ea8c606cf056cf39b7912f046a9..7df9b027dd6f6fd568acb559e2adebff350b3cea 100644
--- a/alib2algo/src/arbology/exact/ReversedBoyerMooreHorspool.cpp
+++ b/alib2algo/src/arbology/exact/ReversedBoyerMooreHorspool.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReversedBoyerMooreHorspool.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,12 +16,12 @@ std::set < unsigned > ReversedBoyerMooreHorspool::match ( const tree::Tree & sub
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarTree = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( ReversedBoyerMooreHorspool::match );
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarPattern = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( ReversedBoyerMooreHorspool::match );
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarNonlinearPattern = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( ReversedBoyerMooreHorspool::match );
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedTree = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( ReversedBoyerMooreHorspool::match );
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedPattern = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( ReversedBoyerMooreHorspool::match );
-auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedNonlinearPattern = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedNonlinearPattern < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarTree = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarTree < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarPattern = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarPattern < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedBarNonlinearPattern = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedBarTree < >, tree::PrefixRankedBarNonlinearPattern < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedTree = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedTree < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedPattern = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedPattern < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorspoolPrefixRankedBarTreePrefixRankedNonlinearPattern = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, tree::PrefixRankedTree < >, tree::PrefixRankedNonlinearPattern < > > ( ReversedBoyerMooreHorspool::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/arbology/indexing/CompressedBitParallelIndexConstruction.cpp b/alib2algo/src/arbology/indexing/CompressedBitParallelIndexConstruction.cpp
index e1019f6e805cd8cdd7470838a1790f2da35494dc..d2a8d13ff57d915447cb31b82e338ba2b439df4a 100644
--- a/alib2algo/src/arbology/indexing/CompressedBitParallelIndexConstruction.cpp
+++ b/alib2algo/src/arbology/indexing/CompressedBitParallelIndexConstruction.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "CompressedBitParallelIndexConstruction.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,9 +16,9 @@ indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < Default
 	return dispatch ( tree.getData ( ) );
 }
 
-auto compressedBitParallelIndexConstructionPrefixRankedTree = CompressedBitParallelIndexConstruction::RegistratorWrapper < indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( CompressedBitParallelIndexConstruction::construct );
+auto compressedBitParallelIndexConstructionPrefixRankedTree = registration::OverloadRegister < CompressedBitParallelIndexConstruction, indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( CompressedBitParallelIndexConstruction::construct );
 
-auto compressedBitParallelIndexConstructionPrefixRankedBarTree = CompressedBitParallelIndexConstruction::RegistratorWrapper < indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( CompressedBitParallelIndexConstruction::construct );
+auto compressedBitParallelIndexConstructionPrefixRankedBarTree = registration::OverloadRegister < CompressedBitParallelIndexConstruction, indexes::arbology::CompressedBitParallelTreeIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( CompressedBitParallelIndexConstruction::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/arbology/indexing/FullAndLinearIndexConstruction.cpp b/alib2algo/src/arbology/indexing/FullAndLinearIndexConstruction.cpp
index e29d4d88befb9f1cf31b90edf3419afc9a505127..98897749f234f17c809bfb30bf517295f10cd182 100644
--- a/alib2algo/src/arbology/indexing/FullAndLinearIndexConstruction.cpp
+++ b/alib2algo/src/arbology/indexing/FullAndLinearIndexConstruction.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "FullAndLinearIndexConstruction.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,8 +16,8 @@ indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType,
 	return dispatch ( tree.getData ( ) );
 }
 
-auto fullAndLinearIndexConstructionPrefixRankedTree = FullAndLinearIndexConstruction::RegistratorWrapper < indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( FullAndLinearIndexConstruction::construct );
-auto fullAndLinearIndexConstructionPrefixRankedBarTree = FullAndLinearIndexConstruction::RegistratorWrapper < indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( FullAndLinearIndexConstruction::construct );
+auto fullAndLinearIndexConstructionPrefixRankedTree = registration::OverloadRegister < FullAndLinearIndexConstruction, indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( FullAndLinearIndexConstruction::construct );
+auto fullAndLinearIndexConstructionPrefixRankedBarTree = registration::OverloadRegister < FullAndLinearIndexConstruction, indexes::arbology::FullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( FullAndLinearIndexConstruction::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/arbology/indexing/NonlinearFullAndLinearIndexConstruction.cpp b/alib2algo/src/arbology/indexing/NonlinearFullAndLinearIndexConstruction.cpp
index 63fbe9709630eb34a3206c4910cbda221d8a5e36..46521fb84faee3fe088fae509bc8c20eb9670e63 100644
--- a/alib2algo/src/arbology/indexing/NonlinearFullAndLinearIndexConstruction.cpp
+++ b/alib2algo/src/arbology/indexing/NonlinearFullAndLinearIndexConstruction.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "NonlinearFullAndLinearIndexConstruction.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,8 +16,8 @@ indexes::arbology::NonlinearFullAndLinearIndex < std::ranked_symbol < DefaultSym
 	return dispatch ( tree.getData ( ) );
 }
 
-auto nonlinearFullAndLinearIndexConstructionPrefixRankedTree = NonlinearFullAndLinearIndexConstruction::RegistratorWrapper < indexes::arbology::NonlinearFullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( NonlinearFullAndLinearIndexConstruction::construct );
-auto nonlinearFullAndLinearIndexConstructionPrefixRankedBarTree = NonlinearFullAndLinearIndexConstruction::RegistratorWrapper < indexes::arbology::NonlinearFullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( NonlinearFullAndLinearIndexConstruction::construct );
+auto nonlinearFullAndLinearIndexConstructionPrefixRankedTree = registration::OverloadRegister < NonlinearFullAndLinearIndexConstruction, indexes::arbology::NonlinearFullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedTree < > > ( NonlinearFullAndLinearIndexConstruction::construct );
+auto nonlinearFullAndLinearIndexConstructionPrefixRankedBarTree = registration::OverloadRegister < NonlinearFullAndLinearIndexConstruction, indexes::arbology::NonlinearFullAndLinearIndex < std::ranked_symbol < DefaultSymbolType, DefaultRankType > >, tree::PrefixRankedBarTree < > > ( NonlinearFullAndLinearIndexConstruction::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/arbology/query/CompressedBitParallelismPatterns.cpp b/alib2algo/src/arbology/query/CompressedBitParallelismPatterns.cpp
index 1d6da3515b01d6b58307d6855ea8fe87506151d5..54c98682af53d42b24ed9c7055fe7f3cc6424422 100644
--- a/alib2algo/src/arbology/query/CompressedBitParallelismPatterns.cpp
+++ b/alib2algo/src/arbology/query/CompressedBitParallelismPatterns.cpp
@@ -8,6 +8,7 @@
 #include "CompressedBitParallelismPatterns.h"
 
 #include <tree/ranked/PrefixRankedPattern.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -17,8 +18,8 @@ std::set < unsigned > CompressedBitParallelismPatterns::query ( const indexes::a
 	return dispatch ( compressedBitParallelIndex, tree.getData ( ) );
 }
 
-auto CompressedBitParallelismPatternsPrefixRankedPattern = CompressedBitParallelismPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedPattern < > > ( CompressedBitParallelismPatterns::query );
-auto CompressedBitParallelismPatternsPrefixRankedBarPattern = CompressedBitParallelismPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarPattern < > > ( CompressedBitParallelismPatterns::query );
+auto CompressedBitParallelismPatternsPrefixRankedPattern = registration::OverloadRegister < CompressedBitParallelismPatterns, std::set < unsigned >, tree::PrefixRankedPattern < > > ( CompressedBitParallelismPatterns::query );
+auto CompressedBitParallelismPatternsPrefixRankedBarPattern = registration::OverloadRegister < CompressedBitParallelismPatterns, std::set < unsigned >, tree::PrefixRankedBarPattern < > > ( CompressedBitParallelismPatterns::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/arbology/query/FullAndLinearIndexPatterns.cpp b/alib2algo/src/arbology/query/FullAndLinearIndexPatterns.cpp
index dde35539758eee43d1822ca8660b4823ce9a8995..39f76f30ce68dee13807ccaa39260abadf55e477 100644
--- a/alib2algo/src/arbology/query/FullAndLinearIndexPatterns.cpp
+++ b/alib2algo/src/arbology/query/FullAndLinearIndexPatterns.cpp
@@ -8,6 +8,7 @@
 #include "FullAndLinearIndexPatterns.h"
 
 #include <tree/ranked/PrefixRankedPattern.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -17,8 +18,8 @@ std::set < unsigned > FullAndLinearIndexPatterns::query ( const indexes::arbolog
 	return dispatch ( fullAndLinearIndex, tree.getData ( ) );
 }
 
-auto fullAndLinearIndexPatternsPrefixRankedPattern = FullAndLinearIndexPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedPattern < > > ( FullAndLinearIndexPatterns::query );
-auto fullAndLinearIndexPatternsPrefixRankedBarPattern = FullAndLinearIndexPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarPattern < > > ( FullAndLinearIndexPatterns::query );
+auto fullAndLinearIndexPatternsPrefixRankedPattern = registration::OverloadRegister < FullAndLinearIndexPatterns, std::set < unsigned >, tree::PrefixRankedPattern < > > ( FullAndLinearIndexPatterns::query );
+auto fullAndLinearIndexPatternsPrefixRankedBarPattern = registration::OverloadRegister < FullAndLinearIndexPatterns, std::set < unsigned >, tree::PrefixRankedBarPattern < > > ( FullAndLinearIndexPatterns::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/arbology/query/NonlinearFullAndLinearIndexPatterns.cpp b/alib2algo/src/arbology/query/NonlinearFullAndLinearIndexPatterns.cpp
index 957011a4c6956f8f807b797e43c299726e6f23fa..e6533ca90ea0f0300a2028611fedfd06ed3f5aab 100644
--- a/alib2algo/src/arbology/query/NonlinearFullAndLinearIndexPatterns.cpp
+++ b/alib2algo/src/arbology/query/NonlinearFullAndLinearIndexPatterns.cpp
@@ -8,6 +8,7 @@
 #include "NonlinearFullAndLinearIndexPatterns.h"
 
 #include <tree/ranked/PrefixRankedPattern.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -17,8 +18,8 @@ std::set < unsigned > NonlinearFullAndLinearIndexPatterns::query ( const indexes
 	return dispatch ( nonlinearFullAndLinearIndex, tree.getData ( ) );
 }
 
-auto nonlinearFullAndLinearIndexPatternsPrefixRankedPattern = NonlinearFullAndLinearIndexPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedNonlinearPattern < > > ( NonlinearFullAndLinearIndexPatterns::query );
-auto nonlinearFullAndLinearIndexPatternsPrefixRankedBarPattern = NonlinearFullAndLinearIndexPatterns::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarNonlinearPattern < > > ( NonlinearFullAndLinearIndexPatterns::query );
+auto nonlinearFullAndLinearIndexPatternsPrefixRankedPattern = registration::OverloadRegister < NonlinearFullAndLinearIndexPatterns, std::set < unsigned >, tree::PrefixRankedNonlinearPattern < > > ( NonlinearFullAndLinearIndexPatterns::query );
+auto nonlinearFullAndLinearIndexPatternsPrefixRankedBarPattern = registration::OverloadRegister < NonlinearFullAndLinearIndexPatterns, std::set < unsigned >, tree::PrefixRankedBarNonlinearPattern < > > ( NonlinearFullAndLinearIndexPatterns::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/arbology/transform/BeginToEndIndex.cpp b/alib2algo/src/arbology/transform/BeginToEndIndex.cpp
index 06031a5e833f911ec7ea780f3afef1bb00c3fcf6..af95b051ffcc5ec207dea591d7453a07c9c61b73 100644
--- a/alib2algo/src/arbology/transform/BeginToEndIndex.cpp
+++ b/alib2algo/src/arbology/transform/BeginToEndIndex.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BeginToEndIndex.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace arbology {
 
@@ -15,8 +16,8 @@ std::set < unsigned > BeginToEndIndex::transform ( const tree::Tree & subject, c
 	return dispatch ( subject.getData ( ), indexes );
 }
 
-auto BeginToEndIndexPrefixRankedBarTreePrefixRankedBarTree = BeginToEndIndex::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedBarTree < > > ( BeginToEndIndex::transform );
-auto BeginToEndIndexPrefixRankedBarTreePrefixRankedBarPattern = BeginToEndIndex::RegistratorWrapper < std::set < unsigned >, tree::PrefixRankedTree < > > ( BeginToEndIndex::transform );
+auto BeginToEndIndexPrefixRankedBarTreePrefixRankedBarTree = registration::OverloadRegister < BeginToEndIndex, std::set < unsigned >, tree::PrefixRankedBarTree < > > ( BeginToEndIndex::transform );
+auto BeginToEndIndexPrefixRankedBarTreePrefixRankedBarPattern = registration::OverloadRegister < BeginToEndIndex, std::set < unsigned >, tree::PrefixRankedTree < > > ( BeginToEndIndex::transform );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/convert/ToGrammar.cpp b/alib2algo/src/automaton/convert/ToGrammar.cpp
index 469033cba8a447bd8323c021142c0f323c2bfec6..24f5d08433465d087633a0597ac020c6acb3cf52 100644
--- a/alib2algo/src/automaton/convert/ToGrammar.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammar.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToGrammar.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,9 +16,9 @@ grammar::Grammar ToGrammar::convert(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto ToGrammarNFA = ToGrammar::RegistratorWrapper<grammar::Grammar, automaton::NFA < > >(ToGrammar::convert);
+auto ToGrammarNFA = registration::OverloadRegister < ToGrammar, grammar::Grammar, automaton::NFA < > >(ToGrammar::convert);
 
-auto ToGrammarDFA = ToGrammar::RegistratorWrapper<grammar::Grammar, automaton::DFA < > >(ToGrammar::convert);
+auto ToGrammarDFA = registration::OverloadRegister < ToGrammar, grammar::Grammar, automaton::DFA < > >(ToGrammar::convert);
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
index 2814f5ae9150fac51e6643c70e1eb69d50b460ac..5b4eeafbe7f95d0a473a8cb50cd0910e21b1b503 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
@@ -10,6 +10,7 @@
 #include <common/createUnique.hpp>
 
 #include <alphabet/InitialSymbol.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -64,7 +65,7 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automato
 	return grammar;
 }
 
-auto ToGrammarLeftRGNFA = ToGrammarLeftRG::RegistratorWrapper<grammar::LeftRG < >, automaton::NFA < > >(ToGrammarLeftRG::convert);
+auto ToGrammarLeftRGNFA = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, automaton::NFA < >  >(ToGrammarLeftRG::convert);
 
 grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton) {
 	std::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
@@ -109,7 +110,7 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton)
 	return grammar;
 }
 
-auto ToGrammarLeftRGDFA = ToGrammarLeftRG::RegistratorWrapper<grammar::LeftRG < >, automaton::DFA<>>(ToGrammarLeftRG::convert);
+auto ToGrammarLeftRGDFA = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, automaton::DFA < > >( ToGrammarLeftRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
index da14f59c2ca095671d14f709d6f87ae7229718c9..7b89abb3c5a68f71c36f591ba494d2a2a938d5a7 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
@@ -7,6 +7,7 @@
 
 #include "ToGrammarRightRG.h"
 #include <common/createUnique.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -57,7 +58,7 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::NFA < > & automa
 	return grammar;
 }
 
-auto ToGrammarRightRGNFA = ToGrammarRightRG::RegistratorWrapper<grammar::RightRG < >, automaton::NFA < > >(ToGrammarRightRG::convert);
+auto ToGrammarRightRGNFA = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, automaton::NFA < >  >(ToGrammarRightRG::convert);
 
 grammar::RightRG < > ToGrammarRightRG::convert(const automaton::DFA<>& automaton) {
 	std::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
@@ -100,7 +101,7 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::DFA<>& automaton
 	return grammar;
 }
 
-auto ToGrammarRightRGDFA = ToGrammarRightRG::RegistratorWrapper<grammar::RightRG < >, automaton::DFA<>>(ToGrammarRightRG::convert);
+auto ToGrammarRightRGDFA = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, automaton::DFA < > >( ToGrammarRightRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
index 00b4a2bda6db3d2d7e68d96b40a16de75c8bee0f..4113c7adb197d3c3be9febe9489da8e38231730d 100644
--- a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
+++ b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
@@ -19,7 +19,7 @@
 #include <automaton/PDA/DPDA.h>
 #include <automaton/PDA/NPDA.h>
 
-#include <factory/XmlDataFactory.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -101,8 +101,8 @@ automaton::NPDA < > ToPostfixPushdownAutomaton::convert ( const automaton::NFTA
 	return automaton;
 }
 
-auto ToAutomatonDFTA = ToPostfixPushdownAutomaton::RegistratorWrapper < automaton::DPDA < >, automaton::DFTA < > > ( ToPostfixPushdownAutomaton::convert );
-auto ToAutomatonNFTA = ToPostfixPushdownAutomaton::RegistratorWrapper < automaton::NPDA < >, automaton::NFTA < > > ( ToPostfixPushdownAutomaton::convert );
+auto ToAutomatonDFTA = registration::OverloadRegister < ToPostfixPushdownAutomaton, automaton::DPDA < >, automaton::DFTA < > > ( ToPostfixPushdownAutomaton::convert );
+auto ToAutomatonNFTA = registration::OverloadRegister < ToPostfixPushdownAutomaton, automaton::NPDA < >, automaton::NFTA < > > ( ToPostfixPushdownAutomaton::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToRegExp.cpp b/alib2algo/src/automaton/convert/ToRegExp.cpp
index cd9f595146d0258f142f5d6efbde1389e8019b3f..70c4788526f5d0a9d4a83e633b3828825e7a6213 100644
--- a/alib2algo/src/automaton/convert/ToRegExp.cpp
+++ b/alib2algo/src/automaton/convert/ToRegExp.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToRegExp.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,12 +16,12 @@ regexp::RegExp ToRegExp::convert(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto ToRegExpEpsilonNFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::EpsilonNFA < > >(ToRegExp::convert);
-auto ToRegExpMultiInitialStateNFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::MultiInitialStateNFA < > >(ToRegExp::convert);
-auto ToRegExpNFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::NFA < > >(ToRegExp::convert);
-auto ToRegExpDFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::DFA<>>(ToRegExp::convert);
-auto ToRegExpExtendedNFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::ExtendedNFA < > >(ToRegExp::convert);
-auto ToRegExpCompactNFA = ToRegExp::RegistratorWrapper<regexp::RegExp, automaton::CompactNFA < > >(ToRegExp::convert);
+auto ToRegExpEpsilonNFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::EpsilonNFA < > > ( ToRegExp::convert );
+auto ToRegExpMultiInitialStateNFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::MultiInitialStateNFA < > > ( ToRegExp::convert );
+auto ToRegExpNFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::NFA < > > ( ToRegExp::convert );
+auto ToRegExpDFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::DFA < > > ( ToRegExp::convert );
+auto ToRegExpExtendedNFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::ExtendedNFA < > > ( ToRegExp::convert );
+auto ToRegExpCompactNFA = registration::OverloadRegister < ToRegExp, regexp::RegExp, automaton::CompactNFA < > > ( ToRegExp::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
index 0284791628f827f631bb821b442b884926697d4a..4a0899969718ab893a1ccb24fd402887b3b0e529 100644
--- a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
+++ b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
@@ -14,6 +14,7 @@
 
 #include "../../equations/RightRegularEquationSolver.h"
 #include <regexp/unbounded/UnboundedRegExpElements.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -50,7 +51,7 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::Epsilon
 	return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
 }
 
-auto ToRegExpAlgebraicEpsilonNFA = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > >(ToRegExpAlgebraic::convert);
+auto ToRegExpAlgebraicEpsilonNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > > ( ToRegExpAlgebraic::convert );
 
 regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::MultiInitialStateNFA < > & automaton ) {
 	equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -81,7 +82,7 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::MultiIn
 	return regexp::UnboundedRegExp < > { regexp::UnboundedRegExpStructure < DefaultSymbolType > ( alternation ) };
 }
 
-auto ToRegExpAlgebraicMultiInitialStateNFA = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > >(ToRegExpAlgebraic::convert);
+auto ToRegExpAlgebraicMultiInitialStateNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > > ( ToRegExpAlgebraic::convert );
 
 regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::NFA < > & automaton ) {
 	equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -104,7 +105,7 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::NFA < >
 	return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
 }
 
-auto ToRegExpAlgebraicNFA = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::NFA < > >(ToRegExpAlgebraic::convert);
+auto ToRegExpAlgebraicNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::NFA < > > ( ToRegExpAlgebraic::convert );
 
 regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::DFA < > & automaton ) {
 	equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -125,7 +126,7 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::DFA < >
 	return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
 }
 
-auto ToRegExpAlgebraicDFA = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::DFA < > >(ToRegExpAlgebraic::convert);
+auto ToRegExpAlgebraicDFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::DFA < > > ( ToRegExpAlgebraic::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp b/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
index 4620ee7b607f130fb36765914d23e0b071db5453..493de15cd2a7de0fa5e3c06f25e39fdb8f879539 100644
--- a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
+++ b/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
@@ -15,6 +15,7 @@
 #include <common/createUnique.hpp>
 
 #include <label/FinalStateLabel.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -48,12 +49,12 @@ regexp::UnboundedRegExp < > ToRegExpStateElimination::convert(const T& automaton
 	return regexp::UnboundedRegExp < > (regexp::simplify::RegExpOptimize::optimize(initialToFinalState));
 }
 
-auto ToRegExpStateEliminationEpsilonNFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationMultiInitialStateNFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationNFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::NFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationDFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::DFA<>>(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationExtendedNFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::ExtendedNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationCompactNFA = ToRegExpStateElimination::RegistratorWrapper<regexp::UnboundedRegExp < >, automaton::CompactNFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationEpsilonNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationMultiInitialStateNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::NFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationDFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::DFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationExtendedNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::ExtendedNFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationCompactNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::CompactNFA < > >(ToRegExpStateElimination::convert);
 
 automaton::ExtendedNFA < > ToRegExpStateElimination::eliminateState(const automaton::ExtendedNFA < > & extendedAutomaton, const DefaultStateType& q) {
 	automaton::ExtendedNFA < > newAutomaton(extendedAutomaton.getInitialState()); // sure that q is neither initial nor final (follows from step 2 - extending ExtendedNFA)
diff --git a/alib2algo/src/automaton/determinize/Determinize.cpp b/alib2algo/src/automaton/determinize/Determinize.cpp
index cf64deb03e28139b6f3ccd16189280ab1bc0e375..cf2b32c8d8e33f8434896103399bfdcc67c1ded3 100644
--- a/alib2algo/src/automaton/determinize/Determinize.cpp
+++ b/alib2algo/src/automaton/determinize/Determinize.cpp
@@ -20,6 +20,7 @@
 #include <automaton/TM/OneTapeDTM.h>
 #include <automaton/TA/DFTA.h>
 #include "automaton/PDA/RealTimeHeightDeterministicNPDA.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -35,37 +36,37 @@ DFA<> Determinize::determinize(const automaton::DFA<>& automaton) {
 	return automaton;
 }
 
-auto DeterminizeDFA = Determinize::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(Determinize::determinize);
+auto DeterminizeDFA = registration::OverloadRegister < Determinize, automaton::DFA<>, automaton::DFA<> >(Determinize::determinize);
 
 DPDA < > Determinize::determinize(const automaton::DPDA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeDPDA = Determinize::RegistratorWrapper<automaton::DPDA < >, automaton::DPDA < > >(Determinize::determinize);
+auto DeterminizeDPDA = registration::OverloadRegister < Determinize, automaton::DPDA < >, automaton::DPDA < > >(Determinize::determinize);
 
 SinglePopDPDA < > Determinize::determinize(const automaton::SinglePopDPDA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeSinglePopDPDA = Determinize::RegistratorWrapper<automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > >(Determinize::determinize);
+auto DeterminizeSinglePopDPDA = registration::OverloadRegister < Determinize, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > >(Determinize::determinize);
 
 InputDrivenDPDA < > Determinize::determinize(const automaton::InputDrivenDPDA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeInputDrivenDPDA = Determinize::RegistratorWrapper<automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > >(Determinize::determinize);
+auto DeterminizeInputDrivenDPDA = registration::OverloadRegister < Determinize, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > >(Determinize::determinize);
 
 VisiblyPushdownDPDA < > Determinize::determinize(const automaton::VisiblyPushdownDPDA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeVisiblyPushdownDPDA = Determinize::RegistratorWrapper<automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > >(Determinize::determinize);
+auto DeterminizeVisiblyPushdownDPDA = registration::OverloadRegister < Determinize, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > >(Determinize::determinize);
 
 RealTimeHeightDeterministicDPDA < > Determinize::determinize(const automaton::RealTimeHeightDeterministicDPDA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeRealTimeHeightDeterministicDPDA = Determinize::RegistratorWrapper<automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > >(Determinize::determinize);
+auto DeterminizeRealTimeHeightDeterministicDPDA = registration::OverloadRegister < Determinize, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > >(Determinize::determinize);
 
 DPDA < > Determinize::determinize(const automaton::NPDA < > & automaton) {
 	automaton::RealTimeHeightDeterministicNPDA < > rhpda = automaton::PDAToRHPDA::convert(automaton);
@@ -73,24 +74,24 @@ DPDA < > Determinize::determinize(const automaton::NPDA < > & automaton) {
 	return automaton::RHPDAToPDA::convert(dpda);
 }
 
-auto DeterminizeNPDA = Determinize::RegistratorWrapper<automaton::DPDA < >, automaton::NPDA < > >(Determinize::determinize);
+auto DeterminizeNPDA = registration::OverloadRegister < Determinize, automaton::DPDA < >, automaton::NPDA < > >(Determinize::determinize);
 
 OneTapeDTM<> Determinize::determinize(const automaton::OneTapeDTM<>& automaton) {
 	return automaton;
 }
 
-auto DeterminizeOneTapeDTM = Determinize::RegistratorWrapper<automaton::OneTapeDTM<>, automaton::OneTapeDTM<>>(Determinize::determinize);
+auto DeterminizeOneTapeDTM = registration::OverloadRegister < Determinize, automaton::OneTapeDTM<>, automaton::OneTapeDTM < > >(Determinize::determinize);
 
 DFTA < > Determinize::determinize(const automaton::DFTA < > & automaton) {
 	return automaton;
 }
 
-auto DeterminizeDFTA = Determinize::RegistratorWrapper<automaton::DFTA < >, automaton::DFTA < > >(Determinize::determinize);
+auto DeterminizeDFTA = registration::OverloadRegister < Determinize, automaton::DFTA < >, automaton::DFTA < > >(Determinize::determinize);
 
 
 
-auto DeterminizeMultiInitialStateNFA = Determinize::RegistratorWrapper < automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::MultiInitialStateNFA < > > ( Determinize::determinize );
-auto DeterminizeNFA = Determinize::RegistratorWrapper < automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::NFA < > > ( Determinize::determinize );
+auto DeterminizeMultiInitialStateNFA = registration::OverloadRegister < Determinize, automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::MultiInitialStateNFA < > > ( Determinize::determinize );
+auto DeterminizeNFA = registration::OverloadRegister < Determinize, automaton::DFA < DefaultSymbolType, std::set < DefaultStateType > >, automaton::NFA < > > ( Determinize::determinize );
 
 } /* namespace determinize */
 
diff --git a/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
index 315c108ae49a47616bb576bfebdee19f55541f15..76a803cbaa919346f65ae880907dc6bc1ad44363 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeIDPDAPart.cxx
@@ -70,7 +70,7 @@ automaton::InputDrivenDPDA < > Determinize::determinize ( const automaton::Input
 	return res;
 }
 
-auto DeterminizeInputDrivenNPDA = Determinize::RegistratorWrapper < automaton::InputDrivenDPDA < >, automaton::InputDrivenNPDA < > > ( Determinize::determinize );
+auto DeterminizeInputDrivenNPDA = registration::OverloadRegister < Determinize, automaton::InputDrivenDPDA < >, automaton::InputDrivenNPDA < > > ( Determinize::determinize );
 
 } /* namespace determinize */
 
diff --git a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
index 6ab425afbaaedda3fb6d08f1547cc74c79c3b6a3..63b2c78a8ae7d3fa04030737083a8ad723cc7557 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeNFTAPart.cxx
@@ -94,7 +94,7 @@ DFTA < > Determinize::determinize(const NFTA < > & nfta) {
 	return res;
 }
 
-auto DeterminizeNFTA = Determinize::RegistratorWrapper<automaton::DFTA < >, automaton::NFTA < > >( Determinize::determinize );
+auto DeterminizeNFTA = registration::OverloadRegister < Determinize, automaton::DFTA < >, automaton::NFTA < > > ( Determinize::determinize );
 
 } /* namespace determinize */
 
diff --git a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
index 3291c4d564d1e49d1e6180c38dd267baff38cec8..ea9c065ff83ef3e6b8ce7552ad3031a5638a3c7b 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeRHDPDAPart.cxx
@@ -277,7 +277,7 @@ automaton::RealTimeHeightDeterministicDPDA < > Determinize::determinize(const au
 	return d;
 }
 
-auto DeterminizeRealTimeHeightDeterministicNPDA = Determinize::RegistratorWrapper<automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicNPDA < > >( Determinize::determinize );
+auto DeterminizeRealTimeHeightDeterministicNPDA = registration::OverloadRegister < Determinize, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( Determinize::determinize );
 
 } /* namespace determinize */
 
diff --git a/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
index 547bd1637984cab277d55ba5d54397c250884152..031355d25900094cd2f8dad44363e30b837e46af 100644
--- a/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
+++ b/alib2algo/src/automaton/determinize/DeterminizeVPAPart.cxx
@@ -205,7 +205,7 @@ automaton::VisiblyPushdownDPDA < > Determinize::determinize(const automaton::Vis
 	return d;
 }
 
-auto DeterminizeVisiblyPushdownNPDA = Determinize::RegistratorWrapper<automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownNPDA < > >( Determinize::determinize );
+auto DeterminizeVisiblyPushdownNPDA = registration::OverloadRegister < Determinize, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownNPDA < > > ( Determinize::determinize );
 
 } /* namespace determinize */
 
diff --git a/alib2algo/src/automaton/generate/RandomizeAutomaton.cpp b/alib2algo/src/automaton/generate/RandomizeAutomaton.cpp
index 1e3b2d8b8d593541d91fd30b2d891b96e972d03b..bb02784f74a9f8bd2eca86190e748286fecd31c2 100644
--- a/alib2algo/src/automaton/generate/RandomizeAutomaton.cpp
+++ b/alib2algo/src/automaton/generate/RandomizeAutomaton.cpp
@@ -7,15 +7,16 @@
 
 #include "RandomizeAutomaton.h"
 #include <automaton/Automaton.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace generate {
 
-auto RandomizeAutomatonDFA = RandomizeAutomaton::RegistratorWrapper < automaton::DFA < >, automaton::DFA < > > ( RandomizeAutomaton::randomize );
-auto RandomizeAutomatonMultiInitialStateNFA = RandomizeAutomaton::RegistratorWrapper < automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( RandomizeAutomaton::randomize );
-auto RandomizeAutomatonNFA = RandomizeAutomaton::RegistratorWrapper < automaton::NFA < >, automaton::NFA < > > ( RandomizeAutomaton::randomize );
-auto RandomizeAutomatonEpsilonNFA = RandomizeAutomaton::RegistratorWrapper < automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( RandomizeAutomaton::randomize );
+auto RandomizeAutomatonDFA = registration::OverloadRegister < RandomizeAutomaton, automaton::DFA < >, automaton::DFA < > > ( RandomizeAutomaton::randomize );
+auto RandomizeAutomatonMultiInitialStateNFA = registration::OverloadRegister < RandomizeAutomaton, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( RandomizeAutomaton::randomize );
+auto RandomizeAutomatonNFA = registration::OverloadRegister < RandomizeAutomaton, automaton::NFA < >, automaton::NFA < > > ( RandomizeAutomaton::randomize );
+auto RandomizeAutomatonEpsilonNFA = registration::OverloadRegister < RandomizeAutomaton, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( RandomizeAutomaton::randomize );
 
 automaton::Automaton RandomizeAutomaton::randomize ( const automaton::Automaton & automaton ) {
 	return dispatch ( automaton.getData ( ) );
diff --git a/alib2algo/src/automaton/properties/AllEpsilonClosure.cpp b/alib2algo/src/automaton/properties/AllEpsilonClosure.cpp
index 064c765b37c2bc512610767e84039ebe6eecb984..78a9c1522cfa558a49b25b26cb7559a85f49ba5f 100644
--- a/alib2algo/src/automaton/properties/AllEpsilonClosure.cpp
+++ b/alib2algo/src/automaton/properties/AllEpsilonClosure.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "AllEpsilonClosure.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace properties {
 
-auto AllEpsilonClosureEpsilonNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::EpsilonNFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureMultiInitialStateNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::MultiInitialStateNFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::NFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureDFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::DFA<>>(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureExtendedNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::ExtendedNFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureCompactNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::CompactNFA < > >(AllEpsilonClosure::allEpsilonClosure);
+auto AllEpsilonClosureEpsilonNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::EpsilonNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureMultiInitialStateNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::MultiInitialStateNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::NFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureDFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::DFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureExtendedNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::ExtendedNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureCompactNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::CompactNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
 
-std::map<DefaultStateType, std::set<DefaultStateType>> AllEpsilonClosure::allEpsilonClosure(const Automaton& automaton) {
-	return dispatch(automaton.getData());
+std::map < DefaultStateType, std::set < DefaultStateType > > AllEpsilonClosure::allEpsilonClosure ( const Automaton& automaton ) {
+	return dispatch ( automaton.getData ( ) );
 }
 
 } /* namespace properties */
diff --git a/alib2algo/src/automaton/properties/EpsilonClosure.cpp b/alib2algo/src/automaton/properties/EpsilonClosure.cpp
index 6061c6c0adcb24d76d6d888ad69e01a123b5b46c..3b7f9dfb9b4b25dc95fbca7300a3d0b161e30b24 100644
--- a/alib2algo/src/automaton/properties/EpsilonClosure.cpp
+++ b/alib2algo/src/automaton/properties/EpsilonClosure.cpp
@@ -6,19 +6,20 @@
  */
 
 #include "EpsilonClosure.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace properties {
 
-auto EpsilonClosureEpsilonNFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::EpsilonNFA < > >(EpsilonClosure::epsilonClosure);
-auto EpsilonClosureMultiInitialStateNFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::MultiInitialStateNFA < > >(EpsilonClosure::epsilonClosure);
-auto EpsilonClosureNFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::NFA < > >(EpsilonClosure::epsilonClosure);
-auto EpsilonClosureDFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::DFA<>>(EpsilonClosure::epsilonClosure);
-auto EpsilonClosureExtendedNFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::ExtendedNFA < > >(EpsilonClosure::epsilonClosure);
-auto EpsilonClosureCompactNFA = EpsilonClosure::RegistratorWrapper<std::set<DefaultStateType>, automaton::CompactNFA < > >(EpsilonClosure::epsilonClosure);
+auto EpsilonClosureEpsilonNFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::EpsilonNFA < > > ( EpsilonClosure::epsilonClosure );
+auto EpsilonClosureMultiInitialStateNFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::MultiInitialStateNFA < > > ( EpsilonClosure::epsilonClosure );
+auto EpsilonClosureNFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::NFA < > > ( EpsilonClosure::epsilonClosure );
+auto EpsilonClosureDFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::DFA < > > ( EpsilonClosure::epsilonClosure );
+auto EpsilonClosureExtendedNFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::ExtendedNFA < > > ( EpsilonClosure::epsilonClosure );
+auto EpsilonClosureCompactNFA = registration::OverloadRegister < EpsilonClosure, std::set < DefaultStateType >, automaton::CompactNFA < > > ( EpsilonClosure::epsilonClosure );
 
-std::set<DefaultStateType> EpsilonClosure::epsilonClosure(const Automaton& automaton, const DefaultStateType& q) {
+std::set < DefaultStateType > EpsilonClosure::epsilonClosure(const Automaton& automaton, const DefaultStateType& q) {
 	return dispatch(automaton.getData(), q);
 }
 
diff --git a/alib2algo/src/automaton/properties/ReachableStates.cpp b/alib2algo/src/automaton/properties/ReachableStates.cpp
index 5130b8555c29c9457e8e04b5b8bb4b019a56c5f0..10657e4c923e7a2aa5f8ca55a2447d327e215adf 100644
--- a/alib2algo/src/automaton/properties/ReachableStates.cpp
+++ b/alib2algo/src/automaton/properties/ReachableStates.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReachableStates.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,12 +16,12 @@ std::set<DefaultStateType> ReachableStates::reachableStates(const Automaton& aut
 	return dispatch(automaton.getData());
 }
 
-auto ReachableStatesEpsilonNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::EpsilonNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::NFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesCompactNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::CompactNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesExtendedNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::ExtendedNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesMultiInitialStateNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::MultiInitialStateNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesDFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::DFA<>>(ReachableStates::reachableStates);
+auto ReachableStatesEpsilonNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::EpsilonNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::NFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesCompactNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::CompactNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesExtendedNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::ExtendedNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesMultiInitialStateNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::MultiInitialStateNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesDFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::DFA < > > ( ReachableStates::reachableStates );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/automaton/properties/UsefullStates.cpp b/alib2algo/src/automaton/properties/UsefullStates.cpp
index 353e9c23a5d9de4814bbb20ae69919aef985ac7a..9d5e6f30defc3bc8c3a80c4f8fcde697342ad2fe 100644
--- a/alib2algo/src/automaton/properties/UsefullStates.cpp
+++ b/alib2algo/src/automaton/properties/UsefullStates.cpp
@@ -6,21 +6,22 @@
  */
 
 #include "UsefullStates.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace properties {
 
-std::set<DefaultStateType> UsefullStates::usefullStates(const Automaton& automaton) {
+std::set < DefaultStateType > UsefullStates::usefullStates(const Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto UsefullStatesEpsilonNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::EpsilonNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::NFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesCompactNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::CompactNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesExtendedNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::ExtendedNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesMultiInitialStateNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::MultiInitialStateNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesDFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::DFA<>>(UsefullStates::usefullStates);
+auto UsefullStatesEpsilonNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::EpsilonNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::NFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesCompactNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::CompactNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesExtendedNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::ExtendedNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesMultiInitialStateNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::MultiInitialStateNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesDFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::DFA < > > ( UsefullStates::usefullStates );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/automaton/run/Accept.cpp b/alib2algo/src/automaton/run/Accept.cpp
index 9252ee6c4c3ede8c44ea00349bb464f56f3d56fa..5b76d09db41c8665264871967f6d4d15ba1ce069 100644
--- a/alib2algo/src/automaton/run/Accept.cpp
+++ b/alib2algo/src/automaton/run/Accept.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Accept.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -23,15 +24,15 @@ bool Accept::accept ( const automaton::Automaton & automaton, const tree::Ranked
 	return dispatch ( automaton.getData ( ), tree );
 }
 
-auto AcceptDFALinearString = Accept::RegistratorWrapper < bool, automaton::DFA < >, string::LinearString < > > ( Accept::accept );
-auto AcceptNFALinearString = Accept::RegistratorWrapper < bool, automaton::NFA < > , string::LinearString < > > ( Accept::accept );
-auto AcceptDFTARankedTree = Accept::RegistratorWrapper < bool, automaton::DFTA < >, tree::RankedTree < > > ( Accept::accept );
-auto AcceptNFTARankedTree = Accept::RegistratorWrapper < bool, automaton::NFTA < >, tree::RankedTree < > > ( Accept::accept );
-auto AcceptInputDrivenDPDALinearString = Accept::RegistratorWrapper < bool, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Accept::accept );
-auto AcceptVisiblyPushdownDPDALinearString = Accept::RegistratorWrapper < bool, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Accept::accept );
-auto AcceptRealTimeHeightDeterministicDPDALinearString = Accept::RegistratorWrapper < bool, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Accept::accept );
-auto AcceptDPDALinearString = Accept::RegistratorWrapper < bool, automaton::DPDA < >, string::LinearString < > > ( Accept::accept );
-auto AcceptNPDTALinearString = Accept::RegistratorWrapper < bool, automaton::NPDTA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptDFALinearString = registration::OverloadRegister < Accept, bool, automaton::DFA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptNFALinearString = registration::OverloadRegister < Accept, bool, automaton::NFA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptDFTARankedTree = registration::OverloadRegister < Accept, bool, automaton::DFTA < >, tree::RankedTree < > > ( Accept::accept );
+auto AcceptNFTARankedTree = registration::OverloadRegister < Accept, bool, automaton::NFTA < >, tree::RankedTree < > > ( Accept::accept );
+auto AcceptInputDrivenDPDALinearString = registration::OverloadRegister < Accept, bool, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptVisiblyPushdownDPDALinearString = registration::OverloadRegister < Accept, bool, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptRealTimeHeightDeterministicDPDALinearString = registration::OverloadRegister < Accept, bool, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptDPDALinearString = registration::OverloadRegister < Accept, bool, automaton::DPDA < >, string::LinearString < > > ( Accept::accept );
+auto AcceptNPDTALinearString = registration::OverloadRegister < Accept, bool, automaton::NPDTA < >, string::LinearString < > > ( Accept::accept );
 
 } /* namespace run */
 
diff --git a/alib2algo/src/automaton/run/Occurrences.cpp b/alib2algo/src/automaton/run/Occurrences.cpp
index ef7b2f57bd6a681bfb2a26be9607a789cc8c873d..2dc4ae662f159b42c3e1066d33c20ed50cba45ca 100644
--- a/alib2algo/src/automaton/run/Occurrences.cpp
+++ b/alib2algo/src/automaton/run/Occurrences.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Occurrences.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -23,12 +24,12 @@ std::set < unsigned > Occurrences::occurrences ( const automaton::Automaton & au
 	return dispatch ( automaton.getData ( ), tree );
 }
 
-auto OccurrencesDFALinearString = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::DFA < >, string::LinearString < > > ( Occurrences::occurrences );
-auto OccurrencesDFTARankedTree = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::DFTA < >, tree::RankedTree < > > ( Occurrences::occurrences );
-auto OccurrencesInputDrivenDPDALinearString = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
-auto OccurrencesVisiblyPushdownDPDALinearString = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
-auto OccurrencesRealTimeHeightDeterministicDPDALinearString = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
-auto OccurrencesDPDALinearString = Occurrences::RegistratorWrapper < std::set < unsigned >, automaton::DPDA < >, string::LinearString < > > ( Occurrences::occurrences );
+auto OccurrencesDFALinearString = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::DFA < >, string::LinearString < > > ( Occurrences::occurrences );
+auto OccurrencesDFTARankedTree = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::DFTA < >, tree::RankedTree < > > ( Occurrences::occurrences );
+auto OccurrencesInputDrivenDPDALinearString = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
+auto OccurrencesVisiblyPushdownDPDALinearString = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
+auto OccurrencesRealTimeHeightDeterministicDPDALinearString = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Occurrences::occurrences );
+auto OccurrencesDPDALinearString = registration::OverloadRegister < Occurrences, std::set < unsigned >, automaton::DPDA < >, string::LinearString < > > ( Occurrences::occurrences );
 
 } /* namespace run */
 
diff --git a/alib2algo/src/automaton/run/Result.cpp b/alib2algo/src/automaton/run/Result.cpp
index f6bbb9005cd997215e14fb0ff4cc26798ccf629e..67a4f7e953e33fe2e9f81d0fc152c43a9a2da43c 100644
--- a/alib2algo/src/automaton/run/Result.cpp
+++ b/alib2algo/src/automaton/run/Result.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Result.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,12 +16,12 @@ DefaultStateType Result::result ( const automaton::Automaton & automaton, const
 	return dispatch ( automaton.getData ( ), object.getData ( ), failLabel );
 }
 
-auto ResultDFALinearString = Result::RegistratorWrapper < DefaultStateType, automaton::DFA < >, string::LinearString < > > ( Result::result );
-auto ResultDFTARankedTree = Result::RegistratorWrapper < DefaultStateType, automaton::DFTA < >, tree::RankedTree < > > ( Result::result );
-auto ResultInputDrivenDPDALinearString = Result::RegistratorWrapper < DefaultStateType, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Result::result );
-auto ResultVisiblyPushdownDPDALinearString = Result::RegistratorWrapper < DefaultStateType, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Result::result );
-auto ResultRealTimeHeightDeterministicDPDALinearString = Result::RegistratorWrapper < DefaultStateType, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Result::result );
-auto ResultDPDALinearString = Result::RegistratorWrapper < DefaultStateType, automaton::DPDA < >, string::LinearString < > > ( Result::result );
+auto ResultDFALinearString = registration::OverloadRegister < Result, DefaultStateType, automaton::DFA < >, string::LinearString < > > ( Result::result );
+auto ResultDFTARankedTree = registration::OverloadRegister < Result, DefaultStateType, automaton::DFTA < >, tree::RankedTree < > > ( Result::result );
+auto ResultInputDrivenDPDALinearString = registration::OverloadRegister < Result, DefaultStateType, automaton::InputDrivenDPDA < >, string::LinearString < > > ( Result::result );
+auto ResultVisiblyPushdownDPDALinearString = registration::OverloadRegister < Result, DefaultStateType, automaton::VisiblyPushdownDPDA < >, string::LinearString < > > ( Result::result );
+auto ResultRealTimeHeightDeterministicDPDALinearString = registration::OverloadRegister < Result, DefaultStateType, automaton::RealTimeHeightDeterministicDPDA < >, string::LinearString < > > ( Result::result );
+auto ResultDPDALinearString = registration::OverloadRegister < Result, DefaultStateType, automaton::DPDA < >, string::LinearString < > > ( Result::result );
 
 } /* namespace run */
 
diff --git a/alib2algo/src/automaton/run/Translate.cpp b/alib2algo/src/automaton/run/Translate.cpp
index fb1bebc5c3321539a2fb7ff83226457974cb5f80..9c396416216fd022c7e95f6afab0b7df37d1dc9a 100644
--- a/alib2algo/src/automaton/run/Translate.cpp
+++ b/alib2algo/src/automaton/run/Translate.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Translate.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -19,7 +20,7 @@ std::set < string::LinearString < > > Translate::translate ( const automaton::Au
 	return dispatch ( automaton.getData ( ), string );
 }
 
-auto TranslateNPDTALinearString = Translate::RegistratorWrapper < std::set < string::LinearString < > >, automaton::NPDTA < >, string::LinearString < > > ( Translate::translate );
+auto TranslateNPDTALinearString = registration::OverloadRegister < Translate, std::set < string::LinearString < > >, automaton::NPDTA < >, string::LinearString < > > ( Translate::translate );
 
 } /* namespace run */
 
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.cpp b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.cpp
index 417297655ef06b29e283af680e3092f1008b6f78..93f04298f8c083c3d74f069211434e66ad80f307 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.cpp
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverIncoming.cpp
@@ -6,15 +6,16 @@
  */
 
 #include "EpsilonRemoverIncoming.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace simplify {
 
-auto EpsilonRemoverIncomingDFA = EpsilonRemoverIncoming::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(EpsilonRemoverIncoming::remove);
-auto EpsilonRemoverIncomingMultiInitialStateNFA = EpsilonRemoverIncoming::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(EpsilonRemoverIncoming::remove);
-auto EpsilonRemoverIncomingNFA = EpsilonRemoverIncoming::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(EpsilonRemoverIncoming::remove);
-auto EpsilonRemoverIncomingEpsilonNFA = EpsilonRemoverIncoming::RegistratorWrapper<automaton::NFA < > , automaton::EpsilonNFA < > >(EpsilonRemoverIncoming::remove);
+auto EpsilonRemoverIncomingDFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingMultiInitialStateNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::NFA < > , automaton::NFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingEpsilonNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::NFA < > , automaton::EpsilonNFA < > > ( EpsilonRemoverIncoming::remove );
 
 automaton::Automaton EpsilonRemoverIncoming::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.cpp b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.cpp
index 2168d23ba939ae68af7e8b337f7d53ea2cff0b71..0bcb7fc4898dc4021c00992f4551d1cfe7ff06e9 100644
--- a/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.cpp
+++ b/alib2algo/src/automaton/simplify/EpsilonRemoverOutgoing.cpp
@@ -6,15 +6,16 @@
  */
 
 #include "EpsilonRemoverOutgoing.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace simplify {
 
-auto EpsilonRemoverOutgoingDFA = EpsilonRemoverOutgoing::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(EpsilonRemoverOutgoing::remove);
-auto EpsilonRemoverOutgoingMultiInitialStateNFA = EpsilonRemoverOutgoing::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(EpsilonRemoverOutgoing::remove);
-auto EpsilonRemoverOutgoingNFA = EpsilonRemoverOutgoing::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(EpsilonRemoverOutgoing::remove);
-auto EpsilonRemoverOutgoingEpsilonNFA = EpsilonRemoverOutgoing::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::EpsilonNFA < > >(EpsilonRemoverOutgoing::remove);
+auto EpsilonRemoverOutgoingDFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingMultiInitialStateNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::NFA < > , automaton::NFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingEpsilonNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::MultiInitialStateNFA < > , automaton::EpsilonNFA < > > ( EpsilonRemoverOutgoing::remove );
 
 automaton::Automaton EpsilonRemoverOutgoing::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2algo/src/automaton/simplify/Minimize.cpp b/alib2algo/src/automaton/simplify/Minimize.cpp
index 110d208996783e91efee270b9dc182a577c6ad3c..55d2cd267fc754bf4f189bfa15a16e23a5cb3ac7 100644
--- a/alib2algo/src/automaton/simplify/Minimize.cpp
+++ b/alib2algo/src/automaton/simplify/Minimize.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Minimize.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,8 +16,8 @@ automaton::Automaton Minimize::minimize(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto MinimizeNFA = Minimize::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>( Minimize::minimize );
-auto MinimizeNFTA = Minimize::RegistratorWrapper<automaton::DFTA<>, automaton::DFTA<>>( Minimize::minimize );
+auto MinimizeNFA = registration::OverloadRegister < Minimize, automaton::DFA < >, automaton::DFA < > >( Minimize::minimize );
+auto MinimizeNFTA = registration::OverloadRegister < Minimize, automaton::DFTA < >, automaton::DFTA < > >( Minimize::minimize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.cpp b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.cpp
index 7cac064e2cf0e2337604f1bf9369fb1e74637356..a7977c9ce4063d31fffa0f28282255989930d266 100644
--- a/alib2algo/src/automaton/simplify/MinimizeBrzozowski.cpp
+++ b/alib2algo/src/automaton/simplify/MinimizeBrzozowski.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "MinimizeBrzozowski.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -17,8 +18,8 @@ automaton::Automaton MinimizeBrzozowski::minimize(const automaton::Automaton& au
 	return res;
 }
 
-auto MinimizeBrzozowskiDFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::DFA < > >(MinimizeBrzozowski::minimize);
-auto MinimizeBrzozowskiNFA = MinimizeBrzozowski::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::NFA < > >(MinimizeBrzozowski::minimize);
+auto MinimizeBrzozowskiDFA = registration::OverloadRegister < MinimizeBrzozowski, automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::DFA < > > ( MinimizeBrzozowski::minimize );
+auto MinimizeBrzozowskiNFA = registration::OverloadRegister < MinimizeBrzozowski, automaton::DFA < DefaultSymbolType, std::set < std::set < DefaultStateType > > >, automaton::NFA < > > ( MinimizeBrzozowski::minimize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/Normalize.cpp b/alib2algo/src/automaton/simplify/Normalize.cpp
index 3701f1a3aed698ea164a2cb43b0008dadc7e49f0..88a29a072ccb5ad5b97800461cc73c8c43b5069b 100644
--- a/alib2algo/src/automaton/simplify/Normalize.cpp
+++ b/alib2algo/src/automaton/simplify/Normalize.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Normalize.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -17,8 +18,8 @@ automaton::Automaton Normalize::normalize(const automaton::Automaton& automaton)
 	return res;
 }
 
-auto NormalizeDFA = Normalize::RegistratorWrapper<automaton::DFA < DefaultSymbolType, unsigned >, automaton::DFA < > >(Normalize::normalize);
-auto NormalizeDPDA = Normalize::RegistratorWrapper<automaton::DPDA < DefaultSymbolType, DefaultEpsilonType, unsigned, unsigned >, automaton::DPDA < > >(Normalize::normalize);
+auto NormalizeDFA = registration::OverloadRegister < Normalize, automaton::DFA < DefaultSymbolType, unsigned >, automaton::DFA < > > ( Normalize::normalize );
+auto NormalizeDPDA = registration::OverloadRegister < Normalize, automaton::DPDA < DefaultSymbolType, DefaultEpsilonType, unsigned, unsigned >, automaton::DPDA < > > ( Normalize::normalize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/Rename.cpp b/alib2algo/src/automaton/simplify/Rename.cpp
index 969cfce1163cc5854045f05c86a9c20526ea31f5..7c8040a0b4272bd4c25eeff2bdbac0d479ca00ed 100644
--- a/alib2algo/src/automaton/simplify/Rename.cpp
+++ b/alib2algo/src/automaton/simplify/Rename.cpp
@@ -14,6 +14,7 @@
 #include <algorithm>
 #include <sstream>
 #include <iostream>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -50,7 +51,7 @@ automaton::DFA<> Rename::rename(const automaton::DFA<>& fsm) {
 	return result;
 }
 
-auto RenameDFA = Rename::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(Rename::rename);
+auto RenameDFA = registration::OverloadRegister < Rename, automaton::DFA < >, automaton::DFA < > > ( Rename::rename );
 
 automaton::DPDA < > Rename::rename(const automaton::DPDA < > & pda) {
 	int counterState = 0;
@@ -92,7 +93,7 @@ automaton::DPDA < > Rename::rename(const automaton::DPDA < > & pda) {
 	return result;
 }
 
-auto RenameDPDA = Rename::RegistratorWrapper<automaton::DPDA < >, automaton::DPDA < > >(Rename::rename);
+auto RenameDPDA = registration::OverloadRegister < Rename, automaton::DPDA < >, automaton::DPDA < > > ( Rename::rename );
 
 automaton::SinglePopDPDA < > Rename::rename(const automaton::SinglePopDPDA < > & pda) {
 	int counterState = 0;
@@ -133,7 +134,7 @@ automaton::SinglePopDPDA < > Rename::rename(const automaton::SinglePopDPDA < > &
 	return result;
 }
 
-auto RenameSinglePopDPDA = Rename::RegistratorWrapper<automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > >(Rename::rename);
+auto RenameSinglePopDPDA = registration::OverloadRegister < Rename, automaton::SinglePopDPDA < >, automaton::SinglePopDPDA < > > ( Rename::rename );
 
 automaton::InputDrivenDPDA < > Rename::rename(const automaton::InputDrivenDPDA < > & pda) {
 	int counter = 0;
@@ -182,7 +183,7 @@ automaton::InputDrivenDPDA < > Rename::rename(const automaton::InputDrivenDPDA <
 	return result;
 }
 
-auto RenameInputDrivenDPDA = Rename::RegistratorWrapper<automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > >(Rename::rename);
+auto RenameInputDrivenDPDA = registration::OverloadRegister < Rename, automaton::InputDrivenDPDA < >, automaton::InputDrivenDPDA < > > ( Rename::rename );
 
 automaton::VisiblyPushdownDPDA < > Rename::rename(const automaton::VisiblyPushdownDPDA < > & pda) {
 	int counterState = 0;
@@ -229,7 +230,7 @@ automaton::VisiblyPushdownDPDA < > Rename::rename(const automaton::VisiblyPushdo
 	return result;
 }
 
-auto RenameVisiblyPushdownDPDA = Rename::RegistratorWrapper<automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > >(Rename::rename);
+auto RenameVisiblyPushdownDPDA = registration::OverloadRegister < Rename, automaton::VisiblyPushdownDPDA < >, automaton::VisiblyPushdownDPDA < > > ( Rename::rename );
 
 automaton::RealTimeHeightDeterministicDPDA < > Rename::rename(const automaton::RealTimeHeightDeterministicDPDA < > & pda) {
 	int counterState = 0;
@@ -274,7 +275,7 @@ automaton::RealTimeHeightDeterministicDPDA < > Rename::rename(const automaton::R
 	return result;
 }
 
-auto RenameRealTimeHeightDeterministicDPDA = Rename::RegistratorWrapper<automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > >(Rename::rename);
+auto RenameRealTimeHeightDeterministicDPDA = registration::OverloadRegister < Rename, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( Rename::rename );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/SingleInitialState.cpp b/alib2algo/src/automaton/simplify/SingleInitialState.cpp
index 9e9303541755438dae540b80df138afa59daf506..ae0e27ccfa9ed563ae3a57b896c638e12b569b7f 100644
--- a/alib2algo/src/automaton/simplify/SingleInitialState.cpp
+++ b/alib2algo/src/automaton/simplify/SingleInitialState.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SingleInitialState.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,12 +16,12 @@ automaton::Automaton SingleInitialState::convert(const Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto SingleInitialStateMultiInitialStateNFA = SingleInitialState::RegistratorWrapper<automaton::NFA < >, automaton::MultiInitialStateNFA < > >(SingleInitialState::convert);
-auto SingleInitialStateDFA = SingleInitialState::RegistratorWrapper<automaton::DFA < >, automaton::DFA < > >(SingleInitialState::convert);
-auto SingleInitialStateEpsilonNFA = SingleInitialState::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(SingleInitialState::convert);
-auto SingleInitialStateNFA = SingleInitialState::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(SingleInitialState::convert);
-auto SingleInitialStateCompactNFA = SingleInitialState::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(SingleInitialState::convert);
-auto SingleInitialStateExtendedNFA = SingleInitialState::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(SingleInitialState::convert);
+auto SingleInitialStateMultiInitialStateNFA = registration::OverloadRegister < SingleInitialState, automaton::NFA < >, automaton::MultiInitialStateNFA < > > ( SingleInitialState::convert );
+auto SingleInitialStateDFA = registration::OverloadRegister < SingleInitialState, automaton::DFA < >, automaton::DFA < > > ( SingleInitialState::convert );
+auto SingleInitialStateEpsilonNFA = registration::OverloadRegister < SingleInitialState, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( SingleInitialState::convert );
+auto SingleInitialStateNFA = registration::OverloadRegister < SingleInitialState, automaton::NFA < > , automaton::NFA < > > ( SingleInitialState::convert );
+auto SingleInitialStateCompactNFA = registration::OverloadRegister < SingleInitialState, automaton::CompactNFA < >, automaton::CompactNFA < > > ( SingleInitialState::convert );
+auto SingleInitialStateExtendedNFA = registration::OverloadRegister < SingleInitialState, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( SingleInitialState::convert );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/Total.cpp b/alib2algo/src/automaton/simplify/Total.cpp
index 4dd40fe3cc9977ff271f0a4f6404d80bbadf115b..decea974d7439dce0c25d99fd2f32ce18d980e9b 100644
--- a/alib2algo/src/automaton/simplify/Total.cpp
+++ b/alib2algo/src/automaton/simplify/Total.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Total.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,8 +16,8 @@ automaton::Automaton Total::total(const Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto TotalNFA = Total::RegistratorWrapper<automaton::NFA < >, automaton::NFA < > >(Total::total);
-auto TotalDFA = Total::RegistratorWrapper<automaton::DFA < >, automaton::DFA < > >(Total::total);
+auto TotalNFA = registration::OverloadRegister < Total, automaton::NFA < >, automaton::NFA < > > ( Total::total );
+auto TotalDFA = registration::OverloadRegister < Total, automaton::DFA < >, automaton::DFA < > > ( Total::total );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/automaton/simplify/Trim.cpp b/alib2algo/src/automaton/simplify/Trim.cpp
index 5e639c8453c79e0a10e9a9ddf936f2b1f6b39ae5..e52e9e2e00c26a09786591e0898efdbde1a432a9 100644
--- a/alib2algo/src/automaton/simplify/Trim.cpp
+++ b/alib2algo/src/automaton/simplify/Trim.cpp
@@ -13,18 +13,19 @@
 #include <automaton/FSM/NFA.h>
 #include <automaton/FSM/DFA.h>
 #include <automaton/TA/DFTA.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace simplify {
 
-auto TrimDFA = Trim::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(Trim::trim);
-auto TrimNFA = Trim::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(Trim::trim);
-auto TrimMultiInitialStateNFA = Trim::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(Trim::trim);
-auto TrimEpsilonNFA = Trim::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(Trim::trim);
-auto TrimCompactNFA = Trim::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(Trim::trim);
-auto TrimExtendedNFA = Trim::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(Trim::trim);
-auto TrimDFTA = Trim::RegistratorWrapper<automaton::DFTA<>, automaton::DFTA<>>(Trim::trim);
+auto TrimDFA = registration::OverloadRegister < Trim, automaton::DFA < >, automaton::DFA < > > ( Trim::trim );
+auto TrimNFA = registration::OverloadRegister < Trim, automaton::NFA < > , automaton::NFA < > >( Trim::trim );
+auto TrimMultiInitialStateNFA = registration::OverloadRegister < Trim, automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > > ( Trim::trim );
+auto TrimEpsilonNFA = registration::OverloadRegister < Trim, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( Trim::trim );
+auto TrimCompactNFA = registration::OverloadRegister < Trim, automaton::CompactNFA < >, automaton::CompactNFA < > > ( Trim::trim );
+auto TrimExtendedNFA = registration::OverloadRegister < Trim, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( Trim::trim );
+auto TrimDFTA = registration::OverloadRegister < Trim, automaton::DFTA < >, automaton::DFTA < > > ( Trim::trim );
 
 automaton::Automaton Trim::trim(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.cpp b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.cpp
index 39701c6f10faa863c0eeaabd9566e128fbe24445..e0050a01e04bfe2b71c88366b6f6fb2dd0c93d90 100644
--- a/alib2algo/src/automaton/simplify/UnreachableStatesRemover.cpp
+++ b/alib2algo/src/automaton/simplify/UnreachableStatesRemover.cpp
@@ -6,18 +6,19 @@
  */
 
 #include "UnreachableStatesRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace simplify {
 
-auto UnreachableStatesRemoverEpsilonNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverCompactNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverExtendedNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverDFA = UnreachableStatesRemover::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverMultiInitialStateNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverDFTA = UnreachableStatesRemover::RegistratorWrapper<automaton::DFTA<>, automaton::DFTA < > >(UnreachableStatesRemover::remove);
+auto UnreachableStatesRemoverEpsilonNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::NFA < > , automaton::NFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverCompactNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::CompactNFA < >, automaton::CompactNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverExtendedNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverDFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::DFA < >, automaton::DFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverMultiInitialStateNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverDFTA = registration::OverloadRegister < UnreachableStatesRemover, automaton::DFTA < >, automaton::DFTA < > > ( UnreachableStatesRemover::remove );
 
 automaton::Automaton UnreachableStatesRemover::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2algo/src/automaton/simplify/UselessStatesRemover.cpp b/alib2algo/src/automaton/simplify/UselessStatesRemover.cpp
index 8b008413f2a8e8b8a90438817c7c87d135fe631c..190ec3c0c67af7192e2b4deb7472d905806ee929 100644
--- a/alib2algo/src/automaton/simplify/UselessStatesRemover.cpp
+++ b/alib2algo/src/automaton/simplify/UselessStatesRemover.cpp
@@ -6,18 +6,19 @@
  */
 
 #include "UselessStatesRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
 namespace simplify {
 
-auto UselessStatesRemoverEpsilonNFA = UselessStatesRemover::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverNFA = UselessStatesRemover::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverCompactNFA = UselessStatesRemover::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverExtendedNFA = UselessStatesRemover::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverDFA = UselessStatesRemover::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(UselessStatesRemover::remove);
-auto UselessStatesRemoverMultiInitialStateNFA = UselessStatesRemover::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverDFTA = UselessStatesRemover::RegistratorWrapper<automaton::DFTA<>, automaton::DFTA<>>(UselessStatesRemover::remove);
+auto UselessStatesRemoverEpsilonNFA = registration::OverloadRegister < UselessStatesRemover, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverNFA = registration::OverloadRegister < UselessStatesRemover, automaton::NFA < > , automaton::NFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverCompactNFA = registration::OverloadRegister < UselessStatesRemover, automaton::CompactNFA < >, automaton::CompactNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverExtendedNFA = registration::OverloadRegister < UselessStatesRemover, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverDFA = registration::OverloadRegister < UselessStatesRemover, automaton::DFA < >, automaton::DFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverMultiInitialStateNFA = registration::OverloadRegister < UselessStatesRemover, automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverDFTA = registration::OverloadRegister < UselessStatesRemover, automaton::DFTA < >, automaton::DFTA < > > ( UselessStatesRemover::remove );
 
 automaton::Automaton UselessStatesRemover::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2algo/src/automaton/transform/AutomataConcatenation.cpp b/alib2algo/src/automaton/transform/AutomataConcatenation.cpp
index 8494c7882689f3cbb5a19425689b8bf472fc0655..fb3641c2df2711308d792b9cc11631451fcb06dd 100644
--- a/alib2algo/src/automaton/transform/AutomataConcatenation.cpp
+++ b/alib2algo/src/automaton/transform/AutomataConcatenation.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "AutomataConcatenation.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,8 +16,8 @@ automaton::Automaton AutomataConcatenation::concatenation(const automaton::Autom
 	return dispatch(first.getData(), second.getData());
 }
 
-auto AutomataConcatenationNFA = AutomataConcatenation::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(AutomataConcatenation::concatenation);
-auto AutomataConcatenationDFA = AutomataConcatenation::RegistratorWrapper<automaton::NFA < > , automaton::DFA < > >(AutomataConcatenation::concatenation);
+auto AutomataConcatenationNFA = registration::OverloadRegister < AutomataConcatenation, automaton::NFA < >, automaton::NFA < > > ( AutomataConcatenation::concatenation );
+auto AutomataConcatenationDFA = registration::OverloadRegister < AutomataConcatenation, automaton::NFA < >, automaton::DFA < > > ( AutomataConcatenation::concatenation );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.cpp b/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.cpp
index a4c7a46399f9df3f1f90b3c1377e1b051112339d..989e9821c720c4219491ff0da01850ab6f89831a 100644
--- a/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.cpp
+++ b/alib2algo/src/automaton/transform/AutomataConcatenationEpsilonTransition.cpp
@@ -7,6 +7,7 @@
 
 #include "AutomataConcatenationEpsilonTransition.h"
 #include <common/DefaultStateType.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -16,9 +17,9 @@ automaton::Automaton AutomataConcatenationEpsilonTransition::concatenation(const
 	return dispatch(first.getData(), second.getData());
 }
 
-auto AutomataConcatenationEpsilonTransitionDFA = AutomataConcatenationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::DFA < > >(AutomataConcatenationEpsilonTransition::concatenation);
-auto AutomataConcatenationEpsilonTransitionNFA = AutomataConcatenationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::NFA < > >(AutomataConcatenationEpsilonTransition::concatenation);
-auto AutomataConcatenationEpsilonTransitionEpsilonNFA = AutomataConcatenationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < > , automaton::EpsilonNFA < > >(AutomataConcatenationEpsilonTransition::concatenation);
+auto AutomataConcatenationEpsilonTransitionDFA = registration::OverloadRegister < AutomataConcatenationEpsilonTransition, automaton::EpsilonNFA < >, automaton::DFA < > > ( AutomataConcatenationEpsilonTransition::concatenation );
+auto AutomataConcatenationEpsilonTransitionNFA = registration::OverloadRegister < AutomataConcatenationEpsilonTransition, automaton::EpsilonNFA < >, automaton::NFA < > > ( AutomataConcatenationEpsilonTransition::concatenation );
+auto AutomataConcatenationEpsilonTransitionEpsilonNFA = registration::OverloadRegister < AutomataConcatenationEpsilonTransition, automaton::EpsilonNFA < > , automaton::EpsilonNFA < > > ( AutomataConcatenationEpsilonTransition::concatenation );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
index 23641c1250fd743e64f80d23e8c4bd6910c36715..f5feba0822c7926cb53e6259894c84634ea59534 100644
--- a/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
+++ b/alib2algo/src/automaton/transform/AutomataIntersectionCartesianProduct.cpp
@@ -7,6 +7,7 @@
 
 #include "AutomataIntersectionCartesianProduct.h"
 #include <common/DefaultStatesPairType.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -18,8 +19,8 @@ automaton::Automaton AutomataIntersectionCartesianProduct::intersection(const au
 	return res;
 }
 
-auto AutomataIntersectionCartesianProductDFA = AutomataIntersectionCartesianProduct::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > >(AutomataIntersectionCartesianProduct::intersection);
-auto AutomataIntersectionCartesianProductNFA = AutomataIntersectionCartesianProduct::RegistratorWrapper<automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > >(AutomataIntersectionCartesianProduct::intersection);
+auto AutomataIntersectionCartesianProductDFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataIntersectionCartesianProduct::intersection );
+auto AutomataIntersectionCartesianProductNFA = registration::OverloadRegister < AutomataIntersectionCartesianProduct, automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataIntersectionCartesianProduct::intersection );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
index b1a7e1748611aa514b6db2930b2349b0a044af93..901d836686814b3e0f7af2bced291032cd62d54e 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
+++ b/alib2algo/src/automaton/transform/AutomataUnionCartesianProduct.cpp
@@ -8,6 +8,7 @@
 #include "AutomataUnionCartesianProduct.h"
 #include <exception/CommonException.h>
 #include <common/DefaultStatesPairType.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -19,8 +20,8 @@ automaton::Automaton AutomataUnionCartesianProduct::unification(const automaton:
 	return res;
 }
 
-auto AutomataUnionCartesianProductDFA = AutomataUnionCartesianProduct::RegistratorWrapper<automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > >(AutomataUnionCartesianProduct::unification);
-auto AutomataUnionCartesianProductNFA = AutomataUnionCartesianProduct::RegistratorWrapper<automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > >(AutomataUnionCartesianProduct::unification);
+auto AutomataUnionCartesianProductDFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::DFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::DFA < > > ( AutomataUnionCartesianProduct::unification );
+auto AutomataUnionCartesianProductNFA = registration::OverloadRegister < AutomataUnionCartesianProduct, automaton::NFA < DefaultSymbolType, std::pair < DefaultStateType, DefaultStateType > >, automaton::NFA < > > ( AutomataUnionCartesianProduct::unification );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.cpp b/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.cpp
index bba6f9ceec573818a32858b3b347ecae3eb763b4..77bcccf9a94974caed546779ce545cc2336e0670 100644
--- a/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.cpp
+++ b/alib2algo/src/automaton/transform/AutomataUnionEpsilonTransition.cpp
@@ -8,6 +8,7 @@
 #include "AutomataUnionEpsilonTransition.h"
 #include <label/InitialStateLabel.h>
 #include <common/createUnique.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -17,9 +18,9 @@ automaton::Automaton AutomataUnionEpsilonTransition::unification(const automaton
 	return dispatch(first.getData(), second.getData());
 }
 
-auto AutomataUnionEpsilonTransitionEpsilonNFA = AutomataUnionEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(AutomataUnionEpsilonTransition::unification);
-auto AutomataUnionEpsilonTransitionNFA = AutomataUnionEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::NFA < > >(AutomataUnionEpsilonTransition::unification);
-auto AutomataUnionEpsilonTransitionDFA = AutomataUnionEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::DFA < > >(AutomataUnionEpsilonTransition::unification);
+auto AutomataUnionEpsilonTransitionEpsilonNFA = registration::OverloadRegister < AutomataUnionEpsilonTransition, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomataUnionEpsilonTransition::unification );
+auto AutomataUnionEpsilonTransitionNFA = registration::OverloadRegister < AutomataUnionEpsilonTransition, automaton::EpsilonNFA < >, automaton::NFA < > > ( AutomataUnionEpsilonTransition::unification );
+auto AutomataUnionEpsilonTransitionDFA = registration::OverloadRegister < AutomataUnionEpsilonTransition, automaton::EpsilonNFA < >, automaton::DFA < > > ( AutomataUnionEpsilonTransition::unification );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomatonIteration.cpp b/alib2algo/src/automaton/transform/AutomatonIteration.cpp
index c079d65a95b789a84b9011c81a6925587e0064ab..f3646df4b1124e2c793a184dc6b7192f0363be6c 100644
--- a/alib2algo/src/automaton/transform/AutomatonIteration.cpp
+++ b/alib2algo/src/automaton/transform/AutomatonIteration.cpp
@@ -7,6 +7,7 @@
 
 #include "AutomatonIteration.h"
 #include <common/createUnique.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -16,8 +17,8 @@ automaton::Automaton AutomatonIteration::iteration(const automaton::Automaton& a
 	return dispatch(automaton.getData());
 }
 
-auto AutomatonIterationDFA = AutomatonIteration::RegistratorWrapper < automaton::NFA < >, automaton::DFA < > > ( AutomatonIteration::iteration );
-auto AutomatonIterationNFA = AutomatonIteration::RegistratorWrapper < automaton::NFA < >, automaton::NFA < > > (AutomatonIteration::iteration);
+auto AutomatonIterationDFA = registration::OverloadRegister < AutomatonIteration, automaton::NFA < >, automaton::DFA < > > ( AutomatonIteration::iteration );
+auto AutomatonIterationNFA = registration::OverloadRegister < AutomatonIteration, automaton::NFA < >, automaton::NFA < > > ( AutomatonIteration::iteration );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.cpp b/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.cpp
index 67d92430aec788a503b8a11116d334d2d1a5d26f..fea903fdb9771aedd2701a5298f3d5ce8d0c671e 100644
--- a/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.cpp
+++ b/alib2algo/src/automaton/transform/AutomatonIterationEpsilonTransition.cpp
@@ -7,6 +7,7 @@
 
 #include "AutomatonIterationEpsilonTransition.h"
 #include <common/createUnique.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -16,9 +17,9 @@ automaton::Automaton AutomatonIterationEpsilonTransition::iteration(const automa
 	return dispatch(automaton.getData());
 }
 
-auto AutomatonIterationEpsilonTransitionDFA = AutomatonIterationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::DFA < > >(AutomatonIterationEpsilonTransition::iteration);
-auto AutomatonIterationEpsilonTransitionNFA = AutomatonIterationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::NFA < > >(AutomatonIterationEpsilonTransition::iteration);
-auto AutomatonIterationEpsilonTransitionEpsilonNFA = AutomatonIterationEpsilonTransition::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(AutomatonIterationEpsilonTransition::iteration);
+auto AutomatonIterationEpsilonTransitionDFA = registration::OverloadRegister < AutomatonIterationEpsilonTransition, automaton::EpsilonNFA < >, automaton::DFA < > > ( AutomatonIterationEpsilonTransition::iteration );
+auto AutomatonIterationEpsilonTransitionNFA = registration::OverloadRegister < AutomatonIterationEpsilonTransition, automaton::EpsilonNFA < >, automaton::NFA < > > ( AutomatonIterationEpsilonTransition::iteration );
+auto AutomatonIterationEpsilonTransitionEpsilonNFA = registration::OverloadRegister < AutomatonIterationEpsilonTransition, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( AutomatonIterationEpsilonTransition::iteration );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/Compaction.cpp b/alib2algo/src/automaton/transform/Compaction.cpp
index 32e58355f55b98738395cc6569dcb63e5a1efb50..a0ece872585510df08312646db00136da2ee471d 100644
--- a/alib2algo/src/automaton/transform/Compaction.cpp
+++ b/alib2algo/src/automaton/transform/Compaction.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Compaction.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,9 +16,9 @@ automaton::Automaton Compaction::convert(const automaton::Automaton& automaton)
 	return dispatch(automaton.getData());
 }
 
-auto CompactionCompactNFA = Compaction::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(Compaction::convert);
-auto CompactionDFA = Compaction::RegistratorWrapper<automaton::CompactNFA < >, automaton::DFA < > >(Compaction::convert);
-auto CompactionNFA = Compaction::RegistratorWrapper<automaton::CompactNFA < >, automaton::NFA < > >(Compaction::convert);
+auto CompactionCompactNFA = registration::OverloadRegister < Compaction, automaton::CompactNFA < >, automaton::CompactNFA < > > ( Compaction::convert );
+auto CompactionDFA = registration::OverloadRegister < Compaction, automaton::CompactNFA < >, automaton::DFA < > > ( Compaction::convert );
+auto CompactionNFA = registration::OverloadRegister < Compaction, automaton::CompactNFA < >, automaton::NFA < > > ( Compaction::convert );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/automaton/transform/PDAToRHPDA.cpp b/alib2algo/src/automaton/transform/PDAToRHPDA.cpp
index 11dd7ea3afb52afff27828968aca466aaa3e04fc..870eecdde93ee5928f82d36342a481e033b9baab 100644
--- a/alib2algo/src/automaton/transform/PDAToRHPDA.cpp
+++ b/alib2algo/src/automaton/transform/PDAToRHPDA.cpp
@@ -22,6 +22,7 @@
 #include <common/createUnique.hpp>
 
 #include <registration/CastRegistration.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -29,13 +30,13 @@ automaton::RealTimeHeightDeterministicDPDA < > PDAToRHPDA::convert ( const autom
 	return pda;
 }
 
-auto PDAToRHPDARealTimeHeightDeterministicDPDA = PDAToRHPDA::RegistratorWrapper < automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( PDAToRHPDA::convert );
+auto PDAToRHPDARealTimeHeightDeterministicDPDA = registration::OverloadRegister < PDAToRHPDA, automaton::RealTimeHeightDeterministicDPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( PDAToRHPDA::convert );
 
 automaton::RealTimeHeightDeterministicNPDA < > PDAToRHPDA::convert ( const automaton::RealTimeHeightDeterministicNPDA < > & pda ) {
 	return pda;
 }
 
-auto PDAToRHPDARealTimeHeightDeterministicNPDA = PDAToRHPDA::RegistratorWrapper < automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( PDAToRHPDA::convert );
+auto PDAToRHPDARealTimeHeightDeterministicNPDA = registration::OverloadRegister < PDAToRHPDA, automaton::RealTimeHeightDeterministicNPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( PDAToRHPDA::convert );
 
 automaton::RealTimeHeightDeterministicDPDA < > PDAToRHPDA::convert ( const automaton::DPDA < > & pda ) {
 	DefaultStateType q0 = common::createUnique ( label::InitialStateLabel::instance < DefaultStateType > ( ), pda.getStates ( ) );
@@ -111,7 +112,7 @@ automaton::RealTimeHeightDeterministicDPDA < > PDAToRHPDA::convert ( const autom
 	return res;
 }
 
-auto PDAToRHPDADPDA = PDAToRHPDA::RegistratorWrapper < automaton::RealTimeHeightDeterministicDPDA < >, automaton::DPDA < > > ( PDAToRHPDA::convert );
+auto PDAToRHPDADPDA = registration::OverloadRegister < PDAToRHPDA, automaton::RealTimeHeightDeterministicDPDA < >, automaton::DPDA < > > ( PDAToRHPDA::convert );
 
 automaton::RealTimeHeightDeterministicNPDA < > PDAToRHPDA::convert ( const automaton::NPDA < > & pda ) {
 	RealTimeHeightDeterministicNPDA < > res ( alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
@@ -185,7 +186,7 @@ automaton::RealTimeHeightDeterministicNPDA < > PDAToRHPDA::convert ( const autom
 	return res;
 }
 
-auto PDAToRHPDANPDA = PDAToRHPDA::RegistratorWrapper < automaton::RealTimeHeightDeterministicNPDA < >, automaton::NPDA < > > ( PDAToRHPDA::convert );
+auto PDAToRHPDANPDA = registration::OverloadRegister < PDAToRHPDA, automaton::RealTimeHeightDeterministicNPDA < >, automaton::NPDA < > > ( PDAToRHPDA::convert );
 
 automaton::Automaton PDAToRHPDA::convert ( const Automaton & automaton ) {
 	return dispatch ( automaton.getData ( ) );
diff --git a/alib2algo/src/automaton/transform/RHPDAToPDA.cpp b/alib2algo/src/automaton/transform/RHPDAToPDA.cpp
index 2a618e91733f2ecc876c597ca44832dea20c5ecf..b300d21fdf6b966b4b1dfe8a44badb11a544adca 100644
--- a/alib2algo/src/automaton/transform/RHPDAToPDA.cpp
+++ b/alib2algo/src/automaton/transform/RHPDAToPDA.cpp
@@ -21,6 +21,7 @@
 #include <iostream>
 
 #include <registration/CastRegistration.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -155,7 +156,7 @@ automaton::DPDA < > RHPDAToPDA::convert ( const automaton::RealTimeHeightDetermi
 	return res;
 }
 
-auto RHPDAToPDARealTimeHeightDeterministicDPDA = RHPDAToPDA::RegistratorWrapper < automaton::DPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( RHPDAToPDA::convert );
+auto RHPDAToPDARealTimeHeightDeterministicDPDA = registration::OverloadRegister < RHPDAToPDA, automaton::DPDA < >, automaton::RealTimeHeightDeterministicDPDA < > > ( RHPDAToPDA::convert );
 
  // This may not work correctly -- generation of initial state and initial symbol
 automaton::NPDA < > RHPDAToPDA::convert ( const automaton::RealTimeHeightDeterministicNPDA < > & pda ) {
@@ -271,7 +272,7 @@ automaton::NPDA < > RHPDAToPDA::convert ( const automaton::RealTimeHeightDetermi
 	return res;
 }
 
-auto RHPDAToPDARealTimeHeightDeterministicNPDA = RHPDAToPDA::RegistratorWrapper < automaton::NPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( RHPDAToPDA::convert );
+auto RHPDAToPDARealTimeHeightDeterministicNPDA = registration::OverloadRegister < RHPDAToPDA, automaton::NPDA < >, automaton::RealTimeHeightDeterministicNPDA < > > ( RHPDAToPDA::convert );
 
 automaton::Automaton RHPDAToPDA::convert ( const Automaton & automaton ) {
 	return dispatch ( automaton.getData ( ) );
diff --git a/alib2algo/src/automaton/transform/Reverse.cpp b/alib2algo/src/automaton/transform/Reverse.cpp
index ed567ffa4b87571472b11d036c91ac15dde22a87..de1af487f4b3c12d3c0ca148818c121d89d17111 100644
--- a/alib2algo/src/automaton/transform/Reverse.cpp
+++ b/alib2algo/src/automaton/transform/Reverse.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "Reverse.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -15,9 +16,9 @@ automaton::Automaton Reverse::convert(const Automaton& automaton) {
 	return dispatch(automaton.getData());
 }
 
-auto ReverseDFA = Reverse::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::DFA<>>(Reverse::convert);
-auto ReverseNFA = Reverse::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::NFA < > >(Reverse::convert);
-auto ReverseMultiInitialStateNFA = Reverse::RegistratorWrapper<automaton::MultiInitialStateNFA < > , automaton::MultiInitialStateNFA < > >(Reverse::convert);
+auto ReverseDFA = registration::OverloadRegister < Reverse, automaton::MultiInitialStateNFA < >, automaton::DFA < > > ( Reverse::convert );
+auto ReverseNFA = registration::OverloadRegister < Reverse, automaton::MultiInitialStateNFA < >, automaton::NFA < > > ( Reverse::convert );
+auto ReverseMultiInitialStateNFA = registration::OverloadRegister < Reverse, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( Reverse::convert );
 
 } /* namespace transform */
 
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
index 57e76a919a220014d6a1b2541788ab114bf4ea80..2c214c1f1eef319a585d6fe7c13801c550747215 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -10,6 +10,7 @@
 
 #include <label/InitialStateLabel.h>
 #include <label/FinalStateLabel.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -60,7 +61,7 @@ automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
 	return automaton;
 }
 
-auto ToAutomatonLeftRG = ToAutomaton::RegistratorWrapper<automaton::NFA < > , grammar::LeftRG < > >(ToAutomaton::convert);
+auto ToAutomatonLeftRG = registration::OverloadRegister < ToAutomaton, automaton::NFA < >, grammar::LeftRG < > > ( ToAutomaton::convert );
 
 automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
 	std::map<DefaultSymbolType, DefaultStateType> stateMap;
@@ -104,7 +105,7 @@ automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
 	return automaton;
 }
 
-auto ToAutomatonRightRG = ToAutomaton::RegistratorWrapper<automaton::NFA < > , grammar::RightRG < > >(ToAutomaton::convert);
+auto ToAutomatonRightRG = registration::OverloadRegister < ToAutomaton, automaton::NFA < >, grammar::RightRG < > > ( ToAutomaton::convert );
 
 template <class T>
 automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
@@ -126,8 +127,8 @@ automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
 	return automaton;
 }
 
-auto ToAutomatonCFG = ToAutomaton::RegistratorWrapper<automaton::NPDA < > , grammar::CFG < > >(ToAutomaton::convert);
-auto ToAutomatonEpsilonFreeCFG = ToAutomaton::RegistratorWrapper<automaton::NPDA < >, grammar::EpsilonFreeCFG < > >(ToAutomaton::convert);
+auto ToAutomatonCFG = registration::OverloadRegister < ToAutomaton, automaton::NPDA < >, grammar::CFG < > > ( ToAutomaton::convert );
+auto ToAutomatonEpsilonFreeCFG = registration::OverloadRegister < ToAutomaton, automaton::NPDA < >, grammar::EpsilonFreeCFG < > > ( ToAutomaton::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
index 20310099e731ef79a194be202da0f990cf79f2c2..3329e1c26eb2f21e243a06d43d4045e253cbc039 100644
--- a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
@@ -5,6 +5,7 @@
  * Author: Tomas Pecka
  */
 #include "ToAutomatonBottomUp.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -14,8 +15,8 @@ automaton::Automaton ToAutomatonBottomUp::convert(const grammar::Grammar& gramma
 	 return dispatch(grammar.getData());
 }
 
-auto ToAutomatonBottomUpCFG = ToAutomatonBottomUp::RegistratorWrapper<automaton::NPDA < > , grammar::CFG < > >(ToAutomatonBottomUp::convert);
-auto ToAutomatonBottomUpEpsilonFreeCFG = ToAutomatonBottomUp::RegistratorWrapper<automaton::NPDA < >, grammar::EpsilonFreeCFG < > >(ToAutomatonBottomUp::convert);
+auto ToAutomatonBottomUpCFG = registration::OverloadRegister < ToAutomatonBottomUp, automaton::NPDA < >, grammar::CFG < > > ( ToAutomatonBottomUp::convert );
+auto ToAutomatonBottomUpEpsilonFreeCFG = registration::OverloadRegister < ToAutomatonBottomUp, automaton::NPDA < >, grammar::EpsilonFreeCFG < > > ( ToAutomatonBottomUp::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
index ab7ae99d6883d0982a91821cefb449bcbbc957e5..33ae387e1d78c9c1602cdf7a88840379341c504f 100644
--- a/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToGrammarLeftRG.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,7 +16,7 @@ grammar::Grammar ToGrammarLeftRG::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
 }
 
-auto ToGrammarLeftRGRightRG = ToGrammarLeftRG::RegistratorWrapper<grammar::LeftRG < >, grammar::RightRG < > >(ToGrammarLeftRG::convert);
+auto ToGrammarLeftRGRightRG = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, grammar::RightRG < > > ( ToGrammarLeftRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
index 062ed8e822eb273bbd0d544bb792e553c2a3b94b..4a549e929322b640ebdb809f55e8a10f28c9470d 100644
--- a/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToGrammarRightRG.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,7 +16,7 @@ grammar::Grammar ToGrammarRightRG::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
 }
 
-auto ToGrammarRightRGLeftRG = ToGrammarRightRG::RegistratorWrapper<grammar::RightRG < >, grammar::LeftRG < > >(ToGrammarRightRG::convert);
+auto ToGrammarRightRGLeftRG = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, grammar::LeftRG < > > ( ToGrammarRightRG::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToRegExp.cpp b/alib2algo/src/grammar/convert/ToRegExp.cpp
index b4c7e4a280cfae42db0333034f194c13e0e2d5fa..692ad5161a0584c010a1c55e80de4999c8ecf07e 100644
--- a/alib2algo/src/grammar/convert/ToRegExp.cpp
+++ b/alib2algo/src/grammar/convert/ToRegExp.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToRegExp.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,8 +16,8 @@ regexp::RegExp ToRegExp::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
 }
 
-auto ToRegExpRightRG = ToRegExp::RegistratorWrapper<regexp::RegExp, grammar::RightRG < > >(ToRegExp::convert);
-auto ToRegExpLeftRG = ToRegExp::RegistratorWrapper<regexp::RegExp, grammar::LeftRG < > >(ToRegExp::convert);
+auto ToRegExpRightRG = registration::OverloadRegister < ToRegExp, regexp::RegExp, grammar::RightRG < > > ( ToRegExp::convert );
+auto ToRegExpLeftRG = registration::OverloadRegister < ToRegExp, regexp::RegExp, grammar::LeftRG < > > ( ToRegExp::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
index a1203f3896f6ef8dbe5e8c19d8a02faecc2bce14..bb1c3d3027262f7e06493531d6ef635d1fa30e3a 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToRegExpAlgebraic.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,8 +16,8 @@ regexp::RegExp ToRegExpAlgebraic::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
 }
 
-auto ToRegExpAlgebraicLeftRG = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, grammar::LeftRG < > >(ToRegExpAlgebraic::convert);
-auto ToRegExpAlgebraicRightRG = ToRegExpAlgebraic::RegistratorWrapper<regexp::UnboundedRegExp < >, grammar::RightRG < > >(ToRegExpAlgebraic::convert);
+auto ToRegExpAlgebraicLeftRG = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, grammar::LeftRG < > > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicRightRG = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, grammar::RightRG < > > ( ToRegExpAlgebraic::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/grammar/generate/CockeYoungerKasami.cpp b/alib2algo/src/grammar/generate/CockeYoungerKasami.cpp
index bc75619a6bafa0ca86315695596fad4fdb0d9e02..b1e57761d2a4a68c33cc8df92c67775a7fe6a4d8 100644
--- a/alib2algo/src/grammar/generate/CockeYoungerKasami.cpp
+++ b/alib2algo/src/grammar/generate/CockeYoungerKasami.cpp
@@ -6,12 +6,13 @@
  */
 
 #include "CockeYoungerKasami.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace generate {
 
-auto CockeYoungerKasamiCNF = CockeYoungerKasami::RegistratorWrapper < bool, grammar::CNF < > > ( CockeYoungerKasami::generate );
+auto CockeYoungerKasamiCNF = registration::OverloadRegister < CockeYoungerKasami, bool, grammar::CNF < > > ( CockeYoungerKasami::generate );
 
 bool CockeYoungerKasami::generate ( const grammar::Grammar & grammar, const string::LinearString < > & string ) {
 	return dispatch ( grammar.getData ( ), string );
diff --git a/alib2algo/src/grammar/generate/GenerateUpToLength.cpp b/alib2algo/src/grammar/generate/GenerateUpToLength.cpp
index 4ad8f0f544d49e80fd637833c26105a814eef961..687a2ecfe9c1ebd4f5a20ddbaf8909451ee1675d 100644
--- a/alib2algo/src/grammar/generate/GenerateUpToLength.cpp
+++ b/alib2algo/src/grammar/generate/GenerateUpToLength.cpp
@@ -6,16 +6,17 @@
  */
 
 #include "GenerateUpToLength.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace generate {
 
-auto GenerateUpToLengthEpsilonFreeCFG = GenerateUpToLength::RegistratorWrapper<std::set<string::LinearString < >>, grammar::EpsilonFreeCFG < > >(GenerateUpToLength::generate);
-auto GenerateUpToLengthGNF = GenerateUpToLength::RegistratorWrapper<std::set<string::LinearString < >>, grammar::GNF < > >(GenerateUpToLength::generate);
-auto GenerateUpToLengthCNF = GenerateUpToLength::RegistratorWrapper<std::set<string::LinearString < >>, grammar::CNF < > >(GenerateUpToLength::generate);
-auto GenerateUpToLengthLeftRG = GenerateUpToLength::RegistratorWrapper<std::set<string::LinearString < >>, grammar::LeftRG < > >(GenerateUpToLength::generate);
-auto GenerateUpToLengthRightRG = GenerateUpToLength::RegistratorWrapper<std::set<string::LinearString < >>, grammar::RightRG < > >(GenerateUpToLength::generate);
+auto GenerateUpToLengthEpsilonFreeCFG = registration::OverloadRegister < GenerateUpToLength, std::set < string::LinearString < > >, grammar::EpsilonFreeCFG < > > ( GenerateUpToLength::generate );
+auto GenerateUpToLengthGNF = registration::OverloadRegister < GenerateUpToLength, std::set < string::LinearString < > >, grammar::GNF < > > ( GenerateUpToLength::generate );
+auto GenerateUpToLengthCNF = registration::OverloadRegister < GenerateUpToLength, std::set < string::LinearString < > >, grammar::CNF < > > ( GenerateUpToLength::generate );
+auto GenerateUpToLengthLeftRG = registration::OverloadRegister < GenerateUpToLength, std::set < string::LinearString < > >, grammar::LeftRG < > > ( GenerateUpToLength::generate );
+auto GenerateUpToLengthRightRG = registration::OverloadRegister < GenerateUpToLength, std::set < string::LinearString < > >, grammar::RightRG < > > ( GenerateUpToLength::generate );
 
 std::set<string::LinearString < >> GenerateUpToLength::generate(const grammar::Grammar& grammar, unsigned length) {
 	return dispatch(grammar.getData(), length);
diff --git a/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp b/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
index 316879b00ce983111365582a72d60d6ac1f726ca..aeb2b0672a95a2c2baa6370c9e218b32da1d45ba 100644
--- a/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
+++ b/alib2algo/src/grammar/generate/RandomGrammarFactory.cpp
@@ -11,6 +11,7 @@
 
 #include <algorithm>
 #include <random>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
diff --git a/alib2algo/src/grammar/generate/RandomizeGrammar.cpp b/alib2algo/src/grammar/generate/RandomizeGrammar.cpp
index 993b6476d836a93a854bc01de9b6949199d0c67f..b349b0d339162f5b5291366a30f2708faefd8532 100644
--- a/alib2algo/src/grammar/generate/RandomizeGrammar.cpp
+++ b/alib2algo/src/grammar/generate/RandomizeGrammar.cpp
@@ -7,16 +7,17 @@
 
 #include "RandomizeGrammar.h"
 #include <grammar/Grammar.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace generate {
 
-auto RandomizeGrammarLeftRG = RandomizeGrammar::RegistratorWrapper < grammar::LeftRG < >, grammar::LeftRG < > > ( RandomizeGrammar::randomize );
-auto RandomizeGrammarLeftLG = RandomizeGrammar::RegistratorWrapper < grammar::LeftLG < >, grammar::LeftLG < > > ( RandomizeGrammar::randomize );
-auto RandomizeGrammarRightRG = RandomizeGrammar::RegistratorWrapper < grammar::RightRG < >, grammar::RightRG < > > ( RandomizeGrammar::randomize );
-auto RandomizeGrammarRightLG = RandomizeGrammar::RegistratorWrapper < grammar::RightLG < >, grammar::RightLG < > > ( RandomizeGrammar::randomize );
-auto RandomizeGrammarCFG = RandomizeGrammar::RegistratorWrapper < grammar::CFG < >, grammar::CFG < > > ( RandomizeGrammar::randomize );
+auto RandomizeGrammarLeftRG = registration::OverloadRegister < RandomizeGrammar, grammar::LeftRG < >, grammar::LeftRG < > > ( RandomizeGrammar::randomize );
+auto RandomizeGrammarLeftLG = registration::OverloadRegister < RandomizeGrammar, grammar::LeftLG < >, grammar::LeftLG < > > ( RandomizeGrammar::randomize );
+auto RandomizeGrammarRightRG = registration::OverloadRegister < RandomizeGrammar, grammar::RightRG < >, grammar::RightRG < > > ( RandomizeGrammar::randomize );
+auto RandomizeGrammarRightLG = registration::OverloadRegister < RandomizeGrammar, grammar::RightLG < >, grammar::RightLG < > > ( RandomizeGrammar::randomize );
+auto RandomizeGrammarCFG = registration::OverloadRegister < RandomizeGrammar, grammar::CFG < >, grammar::CFG < > > ( RandomizeGrammar::randomize );
 
 grammar::Grammar RandomizeGrammar::randomize ( const grammar::Grammar & grammar ) {
 	return dispatch ( grammar.getData ( ) );
diff --git a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
index c0caf51f88fe33304baae77a438b8579f6443828..c510f9d62cbf5e1fff4eb2fb70a3ce99146397c9 100644
--- a/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageEmpty.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "IsLanguageEmpty.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,15 +16,15 @@ bool IsLanguageEmpty::isLanguageEmpty(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
 }
 
-auto IsLanguageEmptyCFG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::CFG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyEpsilonFreeCFG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::EpsilonFreeCFG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyGNF = IsLanguageEmpty::RegistratorWrapper<bool, grammar::GNF < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyCNF = IsLanguageEmpty::RegistratorWrapper<bool, grammar::CNF < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyLeftLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LeftLG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyLeftRG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::LeftRG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyRightLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightLG < > >(IsLanguageEmpty::isLanguageEmpty);
-auto IsLanguageEmptyRightRG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightRG < > >(IsLanguageEmpty::isLanguageEmpty);
+auto IsLanguageEmptyCFG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::CFG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyEpsilonFreeCFG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::EpsilonFreeCFG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyGNF = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::GNF < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyCNF = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::CNF < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyLG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::LG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyLeftLG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::LeftLG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyLeftRG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::LeftRG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyRightLG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::RightLG < > > ( IsLanguageEmpty::isLanguageEmpty );
+auto IsLanguageEmptyRightRG = registration::OverloadRegister < IsLanguageEmpty, bool, grammar::RightRG < > > ( IsLanguageEmpty::isLanguageEmpty );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
index d8666e129fec25e9dc64eddf2169acff67c39dc4..7c126e800c87fb4b2bc77d157766c58dca4adc35 100644
--- a/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
+++ b/alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "IsLanguageGeneratingEpsilon.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,15 +16,15 @@ bool IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon(const grammar::Gra
 	return dispatch(grammar.getData());
 }
 
-auto IsLanguageGeneratingEpsilonCFG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::CFG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonEpsilonFreeCFG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::EpsilonFreeCFG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonGNF = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::GNF < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonCNF = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::CNF < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonLeftLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LeftLG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonLeftRG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::LeftRG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonRightLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightLG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
-auto IsLanguageGeneratingEpsilonRightRG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightRG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
+auto IsLanguageGeneratingEpsilonCFG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::CFG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonEpsilonFreeCFG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::EpsilonFreeCFG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonGNF = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::GNF < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonCNF = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::CNF < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonLG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::LG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonLeftLG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::LeftLG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonLeftRG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::LeftRG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonRightLG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::RightLG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
+auto IsLanguageGeneratingEpsilonRightRG = registration::OverloadRegister < IsLanguageGeneratingEpsilon, bool, grammar::RightRG < > > ( IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
index ae446e250423c90b730af4f5df402ba0fbee5a09..b9e0b06ae8fd5f2a7a66bc97913da7d13cb5b027 100644
--- a/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
+++ b/alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "NonterminalUnitRuleCycle.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace properties {
 
-auto NonterminalUnitRuleCycleCFG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CFG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleEpsilonFreeCFG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::EpsilonFreeCFG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleGNF = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::GNF < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleCNF = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CNF < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleLeftLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftLG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleLeftRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftRG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleRightLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightLG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleRightRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightRG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
+auto NonterminalUnitRuleCycleCFG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::CFG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleEpsilonFreeCFG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::EpsilonFreeCFG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleGNF = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::GNF < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleCNF = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::CNF < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleLG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::LG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleLeftLG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::LeftLG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleLeftRG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::LeftRG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleRightLG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::RightLG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
+auto NonterminalUnitRuleCycleRightRG = registration::OverloadRegister < NonterminalUnitRuleCycle, std::set < DefaultSymbolType >, grammar::RightRG < > > ( NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle );
 
 std::set<DefaultSymbolType> NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle(const grammar::Grammar& grammar, const DefaultSymbolType& nonterminal) {
 	return dispatch(grammar.getData(), nonterminal);
diff --git a/alib2algo/src/grammar/properties/NullableNonterminals.cpp b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
index 3351dc152cf9a8123ce26481946e85a67a202158..30eb6a5c78a14a2a105db32e90a298b5d89554c3 100644
--- a/alib2algo/src/grammar/properties/NullableNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/NullableNonterminals.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "NullableNonterminals.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace properties {
 
-auto NullableNonterminalsCFG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CFG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsEpsilonFreeCFG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::EpsilonFreeCFG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsGNF = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::GNF < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsCNF = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CNF < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsLG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsLeftLG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftLG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsLeftRG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftRG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsRightLG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightLG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsRightRG = NullableNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightRG < > >(NullableNonterminals::getNullableNonterminals);
+auto NullableNonterminalsCFG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::CFG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsEpsilonFreeCFG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::EpsilonFreeCFG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsGNF = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::GNF < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsCNF = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::CNF < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsLG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::LG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsLeftLG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::LeftLG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsLeftRG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::LeftRG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsRightLG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::RightLG < > > ( NullableNonterminals::getNullableNonterminals );
+auto NullableNonterminalsRightRG = registration::OverloadRegister < NullableNonterminals, std::set < DefaultSymbolType >, grammar::RightRG < > > ( NullableNonterminals::getNullableNonterminals );
 
 std::set<DefaultSymbolType> NullableNonterminals::getNullableNonterminals(const grammar::Grammar& grammar ) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
index 9a4662866e7a9930589a06d4bba08deef9ac31f3..595e3f3af0563b6a0be3d6657467a12310b47faf 100644
--- a/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
+++ b/alib2algo/src/grammar/properties/ProductiveNonterminals.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "ProductiveNonterminals.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace properties {
 
-auto ProductiveNonterminalsCFG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CFG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsEpsilonFreeCFG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::EpsilonFreeCFG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsGNF = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::GNF < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsCNF = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CNF < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsLG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsLeftLG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftLG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsLeftRG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftRG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsRightLG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightLG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsRightRG = ProductiveNonterminals::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightRG < > >(ProductiveNonterminals::getProductiveNonterminals);
+auto ProductiveNonterminalsCFG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::CFG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsEpsilonFreeCFG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::EpsilonFreeCFG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsGNF = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::GNF < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsCNF = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::CNF < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsLG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::LG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsLeftLG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::LeftLG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsLeftRG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::LeftRG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsRightLG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::RightLG < > > ( ProductiveNonterminals::getProductiveNonterminals );
+auto ProductiveNonterminalsRightRG = registration::OverloadRegister < ProductiveNonterminals, std::set < DefaultSymbolType >, grammar::RightRG < > > ( ProductiveNonterminals::getProductiveNonterminals );
 
 std::set<DefaultSymbolType> ProductiveNonterminals::getProductiveNonterminals(const grammar::Grammar& grammar ) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
index 3830ae001812f0e9756cade3a42d4d4d99fd861e..afc32c00016f189f29f6bff62035876dad084177 100644
--- a/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
+++ b/alib2algo/src/grammar/properties/RecursiveNonterminal.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "RecursiveNonterminal.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace properties {
 
-auto RecursiveNonterminalCFG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::CFG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalEpsilonFreeCFG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::EpsilonFreeCFG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalGNF = RecursiveNonterminal::RegistratorWrapper < bool, grammar::GNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalCNF = RecursiveNonterminal::RegistratorWrapper < bool, grammar::CNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalLG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalLeftLG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LeftLG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalLeftRG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::LeftRG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalRightLG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightLG < > > ( RecursiveNonterminal::isNonterminalRecursive );
-auto RecursiveNonterminalRightRG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightRG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalCFG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::CFG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalEpsilonFreeCFG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::EpsilonFreeCFG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalGNF = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::GNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalCNF = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::CNF < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalLG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::LG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalLeftLG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::LeftLG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalLeftRG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::LeftRG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalRightLG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::RightLG < > > ( RecursiveNonterminal::isNonterminalRecursive );
+auto RecursiveNonterminalRightRG = registration::OverloadRegister < RecursiveNonterminal, bool, grammar::RightRG < > > ( RecursiveNonterminal::isNonterminalRecursive );
 
 bool RecursiveNonterminal::isNonterminalRecursive ( const grammar::Grammar & grammar, const DefaultSymbolType & nonterminal ) {
 	return dispatch ( grammar.getData ( ), nonterminal );
diff --git a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
index 51b47d3f4a2309ef385c2f21d8f68f06a2d95b2f..28e44eed4b5a551d60111de18f18bc6b57dfd47f 100644
--- a/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
+++ b/alib2algo/src/grammar/properties/UnreachableSymbols.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "UnreachableSymbols.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace properties {
 
-auto UnreachableSymbolsCFG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CFG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsEpsilonFreeCFG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::EpsilonFreeCFG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsGNF = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::GNF < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsCNF = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::CNF < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsLG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsLeftLG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftLG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsLeftRG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::LeftRG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsRightLG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightLG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsRightRG = UnreachableSymbols::RegistratorWrapper<std::set<DefaultSymbolType>, grammar::RightRG < > >(UnreachableSymbols::getUnreachableSymbols);
+auto UnreachableSymbolsCFG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::CFG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsEpsilonFreeCFG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::EpsilonFreeCFG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsGNF = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::GNF < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsCNF = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::CNF < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsLG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::LG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsLeftLG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::LeftLG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsLeftRG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::LeftRG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsRightLG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::RightLG < > > ( UnreachableSymbols::getUnreachableSymbols );
+auto UnreachableSymbolsRightRG = registration::OverloadRegister < UnreachableSymbols, std::set < DefaultSymbolType >, grammar::RightRG < > > ( UnreachableSymbols::getUnreachableSymbols );
 
 std::set < DefaultSymbolType > UnreachableSymbols::getUnreachableSymbols ( const grammar::Grammar & grammar ) {
 	return dispatch ( grammar.getData ( ) );
diff --git a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
index 76abf3b1ba05b50ef5eecf5d10301a3484a7753c..5c9fa06efa9d3ff2224a5b7594e637462a017ded 100644
--- a/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
+++ b/alib2algo/src/grammar/simplify/EpsilonRemover.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "EpsilonRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto EpsilonRemoverCFG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::CFG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverEpsilonFreeCFG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverCNF = EpsilonRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(EpsilonRemover::remove);
-auto EpsilonRemoverGNF = EpsilonRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(EpsilonRemover::remove);
-auto EpsilonRemoverLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverLeftLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::LeftLG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverLeftRG = EpsilonRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverRightLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::RightLG < > >(EpsilonRemover::remove);
-auto EpsilonRemoverRightRG = EpsilonRemover::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(EpsilonRemover::remove);
+auto EpsilonRemoverCFG = registration::OverloadRegister < EpsilonRemover, grammar::EpsilonFreeCFG < >, grammar::CFG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverEpsilonFreeCFG = registration::OverloadRegister < EpsilonRemover, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverCNF = registration::OverloadRegister < EpsilonRemover, grammar::CNF < >, grammar::CNF < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverGNF = registration::OverloadRegister < EpsilonRemover, grammar::GNF < >, grammar::GNF < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverLG = registration::OverloadRegister < EpsilonRemover, grammar::EpsilonFreeCFG < >, grammar::LG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverLeftLG = registration::OverloadRegister < EpsilonRemover, grammar::EpsilonFreeCFG < >, grammar::LeftLG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverLeftRG = registration::OverloadRegister < EpsilonRemover, grammar::LeftRG < >, grammar::LeftRG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverRightLG = registration::OverloadRegister < EpsilonRemover, grammar::EpsilonFreeCFG < >, grammar::RightLG < > > ( EpsilonRemover::remove );
+auto EpsilonRemoverRightRG = registration::OverloadRegister < EpsilonRemover, grammar::RightRG < >, grammar::RightRG < > > ( EpsilonRemover::remove );
 
 grammar::Grammar EpsilonRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp b/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
index 5758a2a683b2718294b817be478faa6edd37fd9c..13f9b113ae842add27cfe9f8537899de6c5e3570 100644
--- a/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
+++ b/alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp
@@ -6,18 +6,19 @@
  */
 
 #include "LeftRecursionRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto LeftRecursionRemoverEpsilonFreeCFG = LeftRecursionRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverCNF = LeftRecursionRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::CNF < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverGNF = LeftRecursionRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverRightRG = LeftRecursionRemover::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverRightLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverLeftRG = LeftRecursionRemover::RegistratorWrapper<grammar::RightRG < >, grammar::LeftRG < > >(LeftRecursionRemover::remove);
-auto LeftRecursionRemoverLeftLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG < >, grammar::LeftLG < > >(LeftRecursionRemover::remove);
+auto LeftRecursionRemoverEpsilonFreeCFG = registration::OverloadRegister < LeftRecursionRemover, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverCNF = registration::OverloadRegister < LeftRecursionRemover, grammar::EpsilonFreeCFG < >, grammar::CNF < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverGNF = registration::OverloadRegister < LeftRecursionRemover, grammar::GNF < >, grammar::GNF < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverRightRG = registration::OverloadRegister < LeftRecursionRemover, grammar::RightRG < >, grammar::RightRG < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverRightLG = registration::OverloadRegister < LeftRecursionRemover, grammar::RightLG < >, grammar::RightLG < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverLeftRG = registration::OverloadRegister < LeftRecursionRemover, grammar::RightRG < >, grammar::LeftRG < > > ( LeftRecursionRemover::remove );
+auto LeftRecursionRemoverLeftLG = registration::OverloadRegister < LeftRecursionRemover, grammar::RightLG < >, grammar::LeftLG < > > ( LeftRecursionRemover::remove );
 
 grammar::Grammar LeftRecursionRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/Rename.cpp b/alib2algo/src/grammar/simplify/Rename.cpp
index 2978978cef5b6af567efecae6f591b59ad00593a..cb85195a1fe2ad9339ce78d9a854c48be087fd90 100644
--- a/alib2algo/src/grammar/simplify/Rename.cpp
+++ b/alib2algo/src/grammar/simplify/Rename.cpp
@@ -16,6 +16,7 @@
 #include <vector>
 
 #include <hexavigesimal>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -61,7 +62,7 @@ grammar::RightRG < > Rename::rename ( const grammar::RightRG < > & rrg ) {
 	return result;
 }
 
-auto RenameRightRG = Rename::RegistratorWrapper < grammar::RightRG < >, grammar::RightRG < > > ( Rename::rename );
+auto RenameRightRG = registration::OverloadRegister < Rename, grammar::RightRG < >, grammar::RightRG < > > ( Rename::rename );
 
 grammar::LeftRG < > Rename::rename ( const grammar::LeftRG < > & rrg ) {
 	int counter = 0;
@@ -99,7 +100,7 @@ grammar::LeftRG < > Rename::rename ( const grammar::LeftRG < > & rrg ) {
 	return result;
 }
 
-auto RenameLeftRG = Rename::RegistratorWrapper < grammar::LeftRG < >, grammar::LeftRG < > > ( Rename::rename );
+auto RenameLeftRG = registration::OverloadRegister < Rename, grammar::LeftRG < >, grammar::LeftRG < > > ( Rename::rename );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
index dad3a970c9a9914c19977981ac68ee04f9d2698d..575ad4aafd8da0173d669096077b9179596242e8 100644
--- a/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
+++ b/alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SimpleRulesRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -15,15 +16,15 @@ grammar::Grammar SimpleRulesRemover::remove ( const grammar::Grammar & grammar )
 	return dispatch ( grammar.getData ( ) );
 }
 
-auto SimpleRulesRemoverCFG = SimpleRulesRemover::RegistratorWrapper<grammar::CFG < >, grammar::CFG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverEpsilonFreeCFG = SimpleRulesRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverCNF = SimpleRulesRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverGNF = SimpleRulesRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverLG = SimpleRulesRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverLeftLG = SimpleRulesRemover::RegistratorWrapper<grammar::LeftLG < >, grammar::LeftLG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverLeftRG = SimpleRulesRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverRightLG = SimpleRulesRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(SimpleRulesRemover::remove);
-auto SimpleRulesRemoverRightRG = SimpleRulesRemover::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(SimpleRulesRemover::remove);
+auto SimpleRulesRemoverCFG = registration::OverloadRegister < SimpleRulesRemover, grammar::CFG < >, grammar::CFG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverEpsilonFreeCFG = registration::OverloadRegister < SimpleRulesRemover, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverCNF = registration::OverloadRegister < SimpleRulesRemover, grammar::CNF < >, grammar::CNF < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverGNF = registration::OverloadRegister < SimpleRulesRemover, grammar::GNF < >, grammar::GNF < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverLG = registration::OverloadRegister < SimpleRulesRemover, grammar::LG < >, grammar::LG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverLeftLG = registration::OverloadRegister < SimpleRulesRemover, grammar::LeftLG < >, grammar::LeftLG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverLeftRG = registration::OverloadRegister < SimpleRulesRemover, grammar::LeftRG < >, grammar::LeftRG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverRightLG = registration::OverloadRegister < SimpleRulesRemover, grammar::RightLG < >, grammar::RightLG < > > ( SimpleRulesRemover::remove );
+auto SimpleRulesRemoverRightRG = registration::OverloadRegister < SimpleRulesRemover, grammar::RightRG < >, grammar::RightRG < > > ( SimpleRulesRemover::remove );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/grammar/simplify/ToCNF.cpp b/alib2algo/src/grammar/simplify/ToCNF.cpp
index 5f527b0e51faf99a3758140e4e9cb10dc3279dd5..de70a44cc92dae932d34030136d38a8a99e7d5c2 100644
--- a/alib2algo/src/grammar/simplify/ToCNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToCNF.cpp
@@ -12,6 +12,7 @@
 #include <common/DefaultSymbolsPairType.h>
 #include <exception/CommonException.h>
 #include <common/createUnique.hpp>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -121,55 +122,55 @@ grammar::CNF < > ToCNF::convert(const grammar::CFG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFCFG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::CFG < > >(ToCNF::convert);
+auto ToCNFCFG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::CFG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::EpsilonFreeCFG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(origGrammar));
 }
 
-auto ToCNFEpsilonFreeCFG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::EpsilonFreeCFG < > >(ToCNF::convert);
+auto ToCNFEpsilonFreeCFG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::EpsilonFreeCFG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::CNF < > & origGrammar) {
 	return origGrammar;
 }
 
-auto ToCNFCNF = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(ToCNF::convert);
+auto ToCNFCNF = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::CNF < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::GNF < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFGNF = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::GNF < > >(ToCNF::convert);
+auto ToCNFGNF = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::GNF < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::LG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LG < > >(ToCNF::convert);
+auto ToCNFLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::LeftLG< > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFLeftLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LeftLG < > >(ToCNF::convert);
+auto ToCNFLeftLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LeftLG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::LeftRG < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFLeftRG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::LeftRG < > >(ToCNF::convert);
+auto ToCNFLeftRG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::LeftRG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::RightLG < > & origGrammar) {
 	return convertInternal(grammar::simplify::SimpleRulesRemover::remove(grammar::simplify::EpsilonRemover::remove(origGrammar)));
 }
 
-auto ToCNFRightLG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::RightLG < > >(ToCNF::convert);
+auto ToCNFRightLG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::RightLG < > > ( ToCNF::convert );
 
 grammar::CNF < > ToCNF::convert(const grammar::RightRG < > & origGrammar) {
 	return convertInternal(origGrammar);
 }
 
-auto ToCNFRightRG = ToCNF::RegistratorWrapper<grammar::CNF < >, grammar::RightRG < > >(ToCNF::convert);
+auto ToCNFRightRG = registration::OverloadRegister < ToCNF, grammar::CNF < >, grammar::RightRG < > > ( ToCNF::convert );
 
 grammar::Grammar ToCNF::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/ToGNF.cpp b/alib2algo/src/grammar/simplify/ToGNF.cpp
index 504937b475b71093c2ef957b239f3f49c7acb81b..557bc9ca1acdb418cc76d9dbd3d036ff7a59c351 100644
--- a/alib2algo/src/grammar/simplify/ToGNF.cpp
+++ b/alib2algo/src/grammar/simplify/ToGNF.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "ToGNF.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto ToGNFCFG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::CFG < > >(ToGNF::convert);
-auto ToGNFEpsilonFreeCFG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::EpsilonFreeCFG < > >(ToGNF::convert);
-auto ToGNFCNF = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::CNF < > >(ToGNF::convert);
-auto ToGNFGNF = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(ToGNF::convert);
-auto ToGNFLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LG < > >(ToGNF::convert);
-auto ToGNFLeftLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::LeftLG < > >(ToGNF::convert);
-auto ToGNFLeftRG = ToGNF::RegistratorWrapper<grammar::RightRG < >, grammar::LeftRG < > >(ToGNF::convert);
-auto ToGNFRightLG = ToGNF::RegistratorWrapper<grammar::GNF < >, grammar::RightLG < > >(ToGNF::convert);
-auto ToGNFRightRG = ToGNF::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(ToGNF::convert);
+auto ToGNFCFG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::CFG < > > ( ToGNF::convert );
+auto ToGNFEpsilonFreeCFG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::EpsilonFreeCFG < > > ( ToGNF::convert );
+auto ToGNFCNF = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::CNF < > > ( ToGNF::convert );
+auto ToGNFGNF = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::GNF < > > ( ToGNF::convert );
+auto ToGNFLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::LG < > > ( ToGNF::convert );
+auto ToGNFLeftLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::LeftLG < > > ( ToGNF::convert );
+auto ToGNFLeftRG = registration::OverloadRegister < ToGNF, grammar::RightRG < >, grammar::LeftRG < > > ( ToGNF::convert );
+auto ToGNFRightLG = registration::OverloadRegister < ToGNF, grammar::GNF < >, grammar::RightLG < > > ( ToGNF::convert );
+auto ToGNFRightRG = registration::OverloadRegister < ToGNF, grammar::RightRG < >, grammar::RightRG < > > ( ToGNF::convert );
 
 grammar::Grammar ToGNF::convert(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/Trim.cpp b/alib2algo/src/grammar/simplify/Trim.cpp
index 046d7fae063d6af0695462c051cb775e1723de26..580585fc283a8e90dd39624a3a4a5f11b08f8f2a 100644
--- a/alib2algo/src/grammar/simplify/Trim.cpp
+++ b/alib2algo/src/grammar/simplify/Trim.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "Trim.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto TrimCFG = Trim::RegistratorWrapper<grammar::CFG < >, grammar::CFG < > >(Trim::trim);
-auto TrimEpsilonFreeCFG = Trim::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(Trim::trim);
-auto TrimGNF = Trim::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(Trim::trim);
-auto TrimCNF = Trim::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(Trim::trim);
-auto TrimLG = Trim::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(Trim::trim);
-auto TrimLeftLG = Trim::RegistratorWrapper<grammar::LeftLG < >, grammar::LeftLG < > >(Trim::trim);
-auto TrimLeftRG = Trim::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(Trim::trim);
-auto TrimRightLG = Trim::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(Trim::trim);
-auto TrimRightRG = Trim::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(Trim::trim);
+auto TrimCFG = registration::OverloadRegister < Trim, grammar::CFG < >, grammar::CFG < > > ( Trim::trim );
+auto TrimEpsilonFreeCFG = registration::OverloadRegister < Trim, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( Trim::trim );
+auto TrimGNF = registration::OverloadRegister < Trim, grammar::GNF < >, grammar::GNF < > > ( Trim::trim );
+auto TrimCNF = registration::OverloadRegister < Trim, grammar::CNF < >, grammar::CNF < > > ( Trim::trim );
+auto TrimLG = registration::OverloadRegister < Trim, grammar::LG < >, grammar::LG < > > ( Trim::trim );
+auto TrimLeftLG = registration::OverloadRegister < Trim, grammar::LeftLG < >, grammar::LeftLG < > > ( Trim::trim );
+auto TrimLeftRG = registration::OverloadRegister < Trim, grammar::LeftRG < >, grammar::LeftRG < > > ( Trim::trim );
+auto TrimRightLG = registration::OverloadRegister < Trim, grammar::RightLG < >, grammar::RightLG < > > ( Trim::trim );
+auto TrimRightRG = registration::OverloadRegister < Trim, grammar::RightRG < >, grammar::RightRG < > > ( Trim::trim );
 
 grammar::Grammar Trim::trim(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
index ba8d91e10fd6f011807e06404ea3a753f29c5fd7..13d2ffab632bead83eddd5c9a82611e3db514f6f 100644
--- a/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnproductiveSymbolsRemover.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "UnproductiveSymbolsRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto UnproductiveSymbolsRemoverCFG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::CFG < >, grammar::CFG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverEpsilonFreeCFG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverGNF = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverCNF = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverLeftLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LeftLG < >, grammar::LeftLG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverLeftRG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverRightLG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(UnproductiveSymbolsRemover::remove);
-auto UnproductiveSymbolsRemoverRightRG = UnproductiveSymbolsRemover::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(UnproductiveSymbolsRemover::remove);
+auto UnproductiveSymbolsRemoverCFG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::CFG < >, grammar::CFG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverEpsilonFreeCFG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverGNF = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::GNF < >, grammar::GNF < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverCNF = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::CNF < >, grammar::CNF < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverLG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::LG < >, grammar::LG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverLeftLG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::LeftLG < >, grammar::LeftLG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverLeftRG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::LeftRG < >, grammar::LeftRG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverRightLG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::RightLG < >, grammar::RightLG < > > ( UnproductiveSymbolsRemover::remove );
+auto UnproductiveSymbolsRemoverRightRG = registration::OverloadRegister < UnproductiveSymbolsRemover, grammar::RightRG < >, grammar::RightRG < > > ( UnproductiveSymbolsRemover::remove );
 
 grammar::Grammar UnproductiveSymbolsRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
index 860b36a43a7a74afa3aa653b81527bf812aab35b..34f73826938c7fcee438cc55c9990d3cb18eeb6a 100644
--- a/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
+++ b/alib2algo/src/grammar/simplify/UnreachableSymbolsRemover.cpp
@@ -6,20 +6,21 @@
  */
 
 #include "UnreachableSymbolsRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
 namespace simplify {
 
-auto UnreachableSymbolsRemoverCFG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::CFG < >, grammar::CFG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverEpsilonFreeCFG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverGNF = UnreachableSymbolsRemover::RegistratorWrapper<grammar::GNF < >, grammar::GNF < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverCNF = UnreachableSymbolsRemover::RegistratorWrapper<grammar::CNF < >, grammar::CNF < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LG < >, grammar::LG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverLeftLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LeftLG < >, grammar::LeftLG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverLeftRG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverRightLG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(UnreachableSymbolsRemover::remove);
-auto UnreachableSymbolsRemoverRightRG = UnreachableSymbolsRemover::RegistratorWrapper<grammar::RightRG < >, grammar::RightRG < > >(UnreachableSymbolsRemover::remove);
+auto UnreachableSymbolsRemoverCFG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::CFG < >, grammar::CFG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverEpsilonFreeCFG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::EpsilonFreeCFG < >, grammar::EpsilonFreeCFG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverGNF = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::GNF < >, grammar::GNF < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverCNF = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::CNF < >, grammar::CNF < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverLG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::LG < >, grammar::LG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverLeftLG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::LeftLG < >, grammar::LeftLG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverLeftRG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::LeftRG < >, grammar::LeftRG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverRightLG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::RightLG < >, grammar::RightLG < > > ( UnreachableSymbolsRemover::remove );
+auto UnreachableSymbolsRemoverRightRG = registration::OverloadRegister < UnreachableSymbolsRemover, grammar::RightRG < >, grammar::RightRG < > > ( UnreachableSymbolsRemover::remove );
 
 grammar::Grammar UnreachableSymbolsRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());
diff --git a/alib2algo/src/regexp/convert/ToAutomaton.cpp b/alib2algo/src/regexp/convert/ToAutomaton.cpp
index e943f5b29887262092481a3cb1b5ca9e3716962b..b24803b209eaf73ab894410fb1dd7974a095d848 100644
--- a/alib2algo/src/regexp/convert/ToAutomaton.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomaton.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToAutomaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -15,8 +16,8 @@ automaton::Automaton ToAutomaton::convert(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto ToAutomatonFormalRegExp = ToAutomaton::RegistratorWrapper<automaton::Automaton, regexp::FormalRegExp < > >(ToAutomaton::convert);
-auto ToAutomatonUnboundedRegExp = ToAutomaton::RegistratorWrapper<automaton::Automaton, regexp::UnboundedRegExp < > >( ToAutomaton::convert);
+auto ToAutomatonFormalRegExp = registration::OverloadRegister < ToAutomaton, automaton::Automaton, regexp::FormalRegExp < > > ( ToAutomaton::convert );
+auto ToAutomatonUnboundedRegExp = registration::OverloadRegister < ToAutomaton, automaton::Automaton, regexp::UnboundedRegExp < > > ( ToAutomaton::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index 188a9f70ca617ace104b0866187a9cf5a7b72fd1..1b38a425e5137bb0ffb8bedbcb89220c0bb4245e 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
@@ -18,6 +18,7 @@
 #include "../transform/RegExpDerivation.h"
 #include "../simplify/RegExpOptimize.h"
 #include "../properties/RegExpEpsilon.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -99,8 +100,8 @@ automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
 	return automaton;
 }
 
-auto ToAutomatonDerivationFormalRegExp = ToAutomatonDerivation::RegistratorWrapper<automaton::DFA<>, regexp::FormalRegExp < > >( ToAutomatonDerivation::convert);
-auto ToAutomatonDerivationUnboundedRegExp = ToAutomatonDerivation::RegistratorWrapper<automaton::DFA<>, regexp::UnboundedRegExp < > >( ToAutomatonDerivation::convert);
+auto ToAutomatonDerivationFormalRegExp = registration::OverloadRegister < ToAutomatonDerivation, automaton::DFA < >, regexp::FormalRegExp < > > ( ToAutomatonDerivation::convert );
+auto ToAutomatonDerivationUnboundedRegExp = registration::OverloadRegister < ToAutomatonDerivation, automaton::DFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonDerivation::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index 466669c8e987940112c1cb064767d80f8200d5f4..54e9b8b8b43c1649a55c640324469b878114b606 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -19,6 +19,7 @@
 
 #include "../properties/RegExpEpsilon.h"
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -81,13 +82,13 @@ automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp
 	return automaton;
 }
 
-auto ToAutomatonGlushkovUnboundedRegExp = ToAutomatonGlushkov::RegistratorWrapper < automaton::NFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovUnboundedRegExp = registration::OverloadRegister < ToAutomatonGlushkov, automaton::NFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonGlushkov::convert );
 
 automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::FormalRegExp < > & /* regexp */ ) {
 	throw exception::CommonException ( "Glushkov: Converting FormalRegExp NYI" ); // TODO
 }
 
-auto ToAutomatonGlushkovFormalRegExp = ToAutomatonGlushkov::RegistratorWrapper < automaton::NFA < >, regexp::FormalRegExp < > > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovFormalRegExp = registration::OverloadRegister < ToAutomatonGlushkov, automaton::NFA < >, regexp::FormalRegExp < > > ( ToAutomatonGlushkov::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
index 6f6a716d2e22dcbb8ab7dbc98327cda70ee58de0..a3b6e1b9c8e54aa32044ae7b78e493edf369f5d6 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
@@ -8,6 +8,7 @@
 #include "regexp/unbounded/UnboundedRegExpElements.h"
 #include "regexp/formal/FormalRegExpElements.h"
 #include <tuple>
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -36,7 +37,7 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::FormalRegEx
 	return automaton;
 }
 
-auto ToAutomatonThompsonFormalRegExp = ToAutomatonThompson::RegistratorWrapper<automaton::EpsilonNFA < >, regexp::FormalRegExp < > >(ToAutomatonThompson::convert);
+auto ToAutomatonThompsonFormalRegExp = registration::OverloadRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, regexp::FormalRegExp < > > ( ToAutomatonThompson::convert );
 
 automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRegExp < > & regexp) {
 	//FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
@@ -57,7 +58,7 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRe
 	return automaton;
 }
 
-auto ToAutomatonThompsonUnboundedRegExp = ToAutomatonThompson::RegistratorWrapper<automaton::EpsilonNFA < >, regexp::UnboundedRegExp < > >(ToAutomatonThompson::convert);
+auto ToAutomatonThompsonUnboundedRegExp = registration::OverloadRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonThompson::convert );
 
 // ----------------------------------------------------------------------------
 
diff --git a/alib2algo/src/regexp/convert/ToGrammar.cpp b/alib2algo/src/regexp/convert/ToGrammar.cpp
index 0b51d8f6ebc172759077921d63e83cf576ab34f2..038582b6b579eca1c1221f6bf365de4e53f2d5c0 100644
--- a/alib2algo/src/regexp/convert/ToGrammar.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammar.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ToGrammar.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -15,8 +16,8 @@ grammar::Grammar ToGrammar::convert(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto ToGrammarFormalRegExp = ToGrammar::RegistratorWrapper<grammar::Grammar, regexp::FormalRegExp < > >(ToGrammar::convert);
-auto ToGrammarUnboundedRegExp = ToGrammar::RegistratorWrapper<grammar::Grammar, regexp::UnboundedRegExp < > >(ToGrammar::convert);
+auto ToGrammarFormalRegExp = registration::OverloadRegister < ToGrammar, grammar::Grammar, regexp::FormalRegExp < > > ( ToGrammar::convert );
+auto ToGrammarUnboundedRegExp = registration::OverloadRegister < ToGrammar, grammar::Grammar, regexp::UnboundedRegExp < > > ( ToGrammar::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index 58eccfe3dfb63f6011c1d42f61a3a29619f14ce3..4bb6176bd6f8f724e12df9b7ce8b10c42d7dda49 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
@@ -18,6 +18,7 @@
 #include "../simplify/RegExpOptimize.h"
 #include "../transform/RegExpDerivation.h"
 #include "../properties/RegExpEpsilon.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -101,8 +102,8 @@ grammar::RightRG < > ToGrammarRightRGDerivation::convert(const T& regexp) {
 	return grammar;
 }
 
-auto ToGrammarRightRGDerivationUnboundedRegExp = ToGrammarRightRGDerivation::RegistratorWrapper<grammar::RightRG < >, regexp::UnboundedRegExp < > >(ToGrammarRightRGDerivation::convert);
-auto ToGrammarRightRGDerivationFormalRegExp = ToGrammarRightRGDerivation::RegistratorWrapper<grammar::RightRG < >, regexp::FormalRegExp < > >(ToGrammarRightRGDerivation::convert);
+auto ToGrammarRightRGDerivationUnboundedRegExp = registration::OverloadRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, regexp::UnboundedRegExp < > > ( ToGrammarRightRGDerivation::convert );
+auto ToGrammarRightRGDerivationFormalRegExp = registration::OverloadRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, regexp::FormalRegExp < > > ( ToGrammarRightRGDerivation::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index d6c47e4031a22e22c9654f4bcded1bd3ecc2de68..be2eec8deea0d4830fc728e407179959ffd6827d 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -18,6 +18,7 @@
 
 #include "../properties/RegExpEpsilon.h"
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -83,13 +84,13 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
 	return grammar;
 }
 
-auto ToGrammarRightRGGlushkovUnboundedRegExp = ToGrammarRightRGGlushkov::RegistratorWrapper < grammar::RightRG < >, regexp::UnboundedRegExp < > > ( ToGrammarRightRGGlushkov::convert );
+auto ToGrammarRightRGGlushkovUnboundedRegExp = registration::OverloadRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, regexp::UnboundedRegExp < > > ( ToGrammarRightRGGlushkov::convert );
 
 grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::FormalRegExp < > & /* regexp */ ) {
 	throw exception::CommonException ( "Glushkov: Converting FormalRegExp NYI" ); // TODO
 }
 
-auto ToGrammarRightRGGlushkovFormalRegExp = ToGrammarRightRGGlushkov::RegistratorWrapper < grammar::RightRG < >, regexp::FormalRegExp < > > ( ToGrammarRightRGGlushkov::convert );
+auto ToGrammarRightRGGlushkovFormalRegExp = registration::OverloadRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, regexp::FormalRegExp < > > ( ToGrammarRightRGGlushkov::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/regexp/properties/RegExpEmpty.cpp b/alib2algo/src/regexp/properties/RegExpEmpty.cpp
index f1a432c47765326a89cb6675ff79d1d8595ca8f5..3d1f5d579fb5b70205debceb11d28d2587b7cecd 100644
--- a/alib2algo/src/regexp/properties/RegExpEmpty.cpp
+++ b/alib2algo/src/regexp/properties/RegExpEmpty.cpp
@@ -8,6 +8,7 @@
 #include "RegExpEmpty.h"
 #include <regexp/formal/FormalRegExpElements.h>
 #include <regexp/unbounded/UnboundedRegExpElements.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -17,8 +18,8 @@ bool RegExpEmpty::languageIsEmpty(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto RegExpEmptyFormalRegExp = RegExpEmpty::RegistratorWrapper<bool, regexp::FormalRegExp < > >( RegExpEmpty::languageIsEmpty);
-auto RegExpEmptyUnboundedRegExp = RegExpEmpty::RegistratorWrapper<bool, regexp::UnboundedRegExp < > >( RegExpEmpty::languageIsEmpty);
+auto RegExpEmptyFormalRegExp = registration::OverloadRegister < RegExpEmpty, bool, regexp::FormalRegExp < > > ( RegExpEmpty::languageIsEmpty );
+auto RegExpEmptyUnboundedRegExp = registration::OverloadRegister < RegExpEmpty, bool, regexp::UnboundedRegExp < > > ( RegExpEmpty::languageIsEmpty );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/regexp/properties/RegExpEpsilon.cpp b/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
index bdfc6f9cde002cbb41693dd8b15e859d77499de4..f1521fc644ba72c85f954db663a485b5e1945686 100644
--- a/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
+++ b/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
@@ -8,6 +8,7 @@
 #include "RegExpEpsilon.h"
 #include <regexp/formal/FormalRegExpElements.h>
 #include <regexp/unbounded/UnboundedRegExpElements.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -17,8 +18,8 @@ bool RegExpEpsilon::languageContainsEpsilon(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto RegExpEpsilonFormalRegExp = RegExpEpsilon::RegistratorWrapper<bool, regexp::FormalRegExp < > >( RegExpEpsilon::languageContainsEpsilon);
-auto RegExpEpsilonUnboundedRegExp = RegExpEpsilon::RegistratorWrapper<bool, regexp::UnboundedRegExp < > >( RegExpEpsilon::languageContainsEpsilon);
+auto RegExpEpsilonFormalRegExp = registration::OverloadRegister < RegExpEpsilon, bool, regexp::FormalRegExp < > > ( RegExpEpsilon::languageContainsEpsilon );
+auto RegExpEpsilonUnboundedRegExp = registration::OverloadRegister < RegExpEpsilon, bool, regexp::UnboundedRegExp < > > ( RegExpEpsilon::languageContainsEpsilon );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimize.cpp b/alib2algo/src/regexp/simplify/RegExpOptimize.cpp
index 89c3430354166ed5017ba52e6fc4f41e770890c1..3aeb040de1567ce2d41e884ca43403152ddf31c3 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimize.cpp
+++ b/alib2algo/src/regexp/simplify/RegExpOptimize.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpOptimize.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -15,8 +16,8 @@ regexp::RegExp RegExpOptimize::optimize(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto RegExpOptimizeFormalRegExp = RegExpOptimize::RegistratorWrapper<FormalRegExp < >, FormalRegExp < > >(RegExpOptimize::optimize);
-auto RegExpOptimizeUnboundedRegExp = RegExpOptimize::RegistratorWrapper<UnboundedRegExp < >, UnboundedRegExp < > >(RegExpOptimize::optimize);
+auto RegExpOptimizeFormalRegExp = registration::OverloadRegister < RegExpOptimize, FormalRegExp < >, FormalRegExp < > > ( RegExpOptimize::optimize );
+auto RegExpOptimizeUnboundedRegExp = registration::OverloadRegister < RegExpOptimize, UnboundedRegExp < >, UnboundedRegExp < > > ( RegExpOptimize::optimize );
 
 } /* namespace regexp */
 
diff --git a/alib2algo/src/regexp/transform/RegExpAlternate.cpp b/alib2algo/src/regexp/transform/RegExpAlternate.cpp
index 990d1c3babdcbd8751dbdd8a95cd41131a3a1470..0f1897263a79aa17867009ce1392b78421027da2 100644
--- a/alib2algo/src/regexp/transform/RegExpAlternate.cpp
+++ b/alib2algo/src/regexp/transform/RegExpAlternate.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpAlternate.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -13,7 +14,7 @@ regexp::RegExp RegExpAlternate::alternate(const regexp::RegExp& first, const reg
 	return dispatch(first.getData(), second.getData());
 }
 
-auto RegExpAlternateFormalRegExp = RegExpAlternate::RegistratorWrapper<regexp::FormalRegExp < > , regexp::FormalRegExp < > >(RegExpAlternate::alternate);
-auto RegExpAlternateUnboundedRegExp = RegExpAlternate::RegistratorWrapper<regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > >(RegExpAlternate::alternate);
+auto RegExpAlternateFormalRegExp = registration::OverloadRegister < RegExpAlternate, regexp::FormalRegExp < > , regexp::FormalRegExp < > > ( RegExpAlternate::alternate );
+auto RegExpAlternateUnboundedRegExp = registration::OverloadRegister < RegExpAlternate, regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpAlternate::alternate );
 
 } /* namespace regexp */
diff --git a/alib2algo/src/regexp/transform/RegExpConcatenate.cpp b/alib2algo/src/regexp/transform/RegExpConcatenate.cpp
index 3dc1f3be4e4b3fc2b41b773de9f8b1706e065288..1139d0c5f345754aa619cd91fbf8af7982fc8c55 100644
--- a/alib2algo/src/regexp/transform/RegExpConcatenate.cpp
+++ b/alib2algo/src/regexp/transform/RegExpConcatenate.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpConcatenate.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -13,7 +14,7 @@ regexp::RegExp RegExpConcatenate::concatenate(const regexp::RegExp& first, const
 	return dispatch(first.getData(), second.getData());
 }
 
-auto RegExpConcatenateFormalRegExp = RegExpConcatenate::RegistratorWrapper<regexp::FormalRegExp < >, regexp::FormalRegExp < > > (RegExpConcatenate::concatenate);
-auto RegExpConcatenateUnboundedRegExp = RegExpConcatenate::RegistratorWrapper<regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > >(RegExpConcatenate::concatenate);
+auto RegExpConcatenateFormalRegExp = registration::OverloadRegister < RegExpConcatenate, regexp::FormalRegExp < >, regexp::FormalRegExp < > > ( RegExpConcatenate::concatenate );
+auto RegExpConcatenateUnboundedRegExp = registration::OverloadRegister < RegExpConcatenate, regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpConcatenate::concatenate );
 
 } /* namespace regexp */
diff --git a/alib2algo/src/regexp/transform/RegExpDerivation.cpp b/alib2algo/src/regexp/transform/RegExpDerivation.cpp
index b1e7852540bc459d41968901c335500d0833f4f9..ace0c75095b81423c1c9568577b70c62b92c99d9 100644
--- a/alib2algo/src/regexp/transform/RegExpDerivation.cpp
+++ b/alib2algo/src/regexp/transform/RegExpDerivation.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpDerivation.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -13,7 +14,7 @@ regexp::RegExp RegExpDerivation::derivation(const regexp::RegExp& regexp, const
 	return dispatch(regexp.getData(), string);
 }
 
-auto RegExpDerivationFormalRegExp = RegExpDerivation::RegistratorWrapper<regexp::FormalRegExp < >, regexp::FormalRegExp < > >(RegExpDerivation::derivation);
-auto RegExpDerivationUnboundedRegExp = RegExpDerivation::RegistratorWrapper<regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > >(RegExpDerivation::derivation);
+auto RegExpDerivationFormalRegExp = registration::OverloadRegister < RegExpDerivation, regexp::FormalRegExp < >, regexp::FormalRegExp < > > ( RegExpDerivation::derivation );
+auto RegExpDerivationUnboundedRegExp = registration::OverloadRegister < RegExpDerivation, regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpDerivation::derivation );
 
 } /* namespace regexp */
diff --git a/alib2algo/src/regexp/transform/RegExpIntegral.cpp b/alib2algo/src/regexp/transform/RegExpIntegral.cpp
index f4558d7350da8cb0b2a11abff45ccb62cca2a4d9..dc980d025b9b61b0c866e0cd8d0c49cb595564c0 100644
--- a/alib2algo/src/regexp/transform/RegExpIntegral.cpp
+++ b/alib2algo/src/regexp/transform/RegExpIntegral.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpIntegral.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -13,7 +14,7 @@ regexp::RegExp RegExpIntegral::integral(const regexp::RegExp& regexp, const stri
 	return dispatch(regexp.getData(), string);
 }
 
-auto RegExpIntegralFormalRegExp = RegExpIntegral::RegistratorWrapper<regexp::FormalRegExp < >, regexp::FormalRegExp < > > ( RegExpIntegral::integral );
-auto RegExpIntegralUnboundedRegExp = RegExpIntegral::RegistratorWrapper<regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpIntegral::integral );
+auto RegExpIntegralFormalRegExp = registration::OverloadRegister < RegExpIntegral, regexp::FormalRegExp < >, regexp::FormalRegExp < > > ( RegExpIntegral::integral );
+auto RegExpIntegralUnboundedRegExp = registration::OverloadRegister < RegExpIntegral, regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpIntegral::integral );
 
 } /* namespace regexp */
diff --git a/alib2algo/src/regexp/transform/RegExpIterate.cpp b/alib2algo/src/regexp/transform/RegExpIterate.cpp
index b89f3897746c385492c11b69748670b81d24aebf..4205a203f8395b7003700700bb2c9d0ae3cb4fdb 100644
--- a/alib2algo/src/regexp/transform/RegExpIterate.cpp
+++ b/alib2algo/src/regexp/transform/RegExpIterate.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpIterate.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -13,7 +14,7 @@ regexp::RegExp RegExpIterate::iterate(const regexp::RegExp& regexp) {
 	return dispatch(regexp.getData());
 }
 
-auto RegExpIterateFormalRegExpFormalRegExp = RegExpIterate::RegistratorWrapper<regexp::FormalRegExp < >, regexp::FormalRegExp < > >(RegExpIterate::iterate);
-auto RegExpIterateUnboundedRegExpUnboundedRegExp = RegExpIterate::RegistratorWrapper<regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > >(RegExpIterate::iterate);
+auto RegExpIterateFormalRegExpFormalRegExp = registration::OverloadRegister < RegExpIterate, regexp::FormalRegExp < >, regexp::FormalRegExp < > > ( RegExpIterate::iterate );
+auto RegExpIterateUnboundedRegExpUnboundedRegExp = registration::OverloadRegister < RegExpIterate, regexp::UnboundedRegExp < >, regexp::UnboundedRegExp < > > ( RegExpIterate::iterate );
 
 } /* namespace regexp */
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomaton.cpp b/alib2algo/src/rte/convert/ToPostfixPushdownAutomaton.cpp
index 44726d5bf1c7790df33e23009e7aebc1c8bbd8db..4d10836452b4b2a6a46ae4c03fd222e20539876c 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomaton.cpp
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomaton.cpp
@@ -8,6 +8,7 @@
 #include "ToPostfixPushdownAutomaton.h"
 #include "ToPostfixPushdownAutomatonGlushkov.h"
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace rte {
 
@@ -21,7 +22,7 @@ automaton::Automaton ToPostfixPushdownAutomaton::convert ( const rte::FormalRTE
 	return automaton::Automaton ( ToPostfixPushdownAutomatonGlushkov::convert ( rte ) );
 }
 
-auto ToAutomatonFormalRegExp = ToPostfixPushdownAutomaton::RegistratorWrapper < automaton::Automaton, rte::FormalRTE < > > ( ToPostfixPushdownAutomaton::convert );
+auto ToAutomatonFormalRegExp = registration::OverloadRegister < ToPostfixPushdownAutomaton, automaton::Automaton, rte::FormalRTE < > > ( ToPostfixPushdownAutomaton::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
index 376e5cdb46f070f465b4ba377c26b9c1a3e4deb8..c32399341808fc7225117620564bd5f4a8381f57 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
@@ -17,6 +17,7 @@
 #include "../glushkov/GlushkovFollow.h"
 #include "../glushkov/GlushkovIndexate.h"
 #include "../glushkov/GlushkovFirst.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace rte {
 
@@ -135,7 +136,7 @@ automaton::NPDA < > ToPostfixPushdownAutomatonGlushkov::convert ( const rte::For
 	return automaton;
 }
 
-auto ToAutomatonGlushkovFormalRegExp = ToPostfixPushdownAutomatonGlushkov::RegistratorWrapper < automaton::NPDA < >, rte::FormalRTE < > > ( ToPostfixPushdownAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovFormalRegExp = registration::OverloadRegister < ToPostfixPushdownAutomatonGlushkov, automaton::NPDA < >, rte::FormalRTE < > > ( ToPostfixPushdownAutomatonGlushkov::convert );
 
 } /* namespace convert */
 
diff --git a/alib2algo/src/string/generate/RandomSubstringFactory.cpp b/alib2algo/src/string/generate/RandomSubstringFactory.cpp
index f624a03a54b9752151090b29b3affb093f4b7a52..be69bb6f0da0b683bd2b6f6b72fc2086cce28be9 100644
--- a/alib2algo/src/string/generate/RandomSubstringFactory.cpp
+++ b/alib2algo/src/string/generate/RandomSubstringFactory.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RandomSubstringFactory.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ string::String RandomSubstringFactory::generateSubstring ( size_t size, const st
 	return dispatch ( size, v.getData ( ) );
 }
 
-auto RandomSubstringFactoryLinearString = RandomSubstringFactory::RegistratorWrapper < string::LinearString < >, string::LinearString < > > ( RandomSubstringFactory::generateSubstring );
+auto RandomSubstringFactoryLinearString = registration::OverloadRegister < RandomSubstringFactory, string::LinearString < >, string::LinearString < > > ( RandomSubstringFactory::generateSubstring );
 
 } /* namespace generate */
 
diff --git a/alib2algo/src/string/naive/ExactCompare.cpp b/alib2algo/src/string/naive/ExactCompare.cpp
index fe94c525c0a85b1f048b08d906ad2ca9ad6f75c6..8dff42d6772b7f2569c9815ea7c365afd9b5dc28 100644
--- a/alib2algo/src/string/naive/ExactCompare.cpp
+++ b/alib2algo/src/string/naive/ExactCompare.cpp
@@ -9,6 +9,7 @@
 #include "string/LinearString.h"
 #include "string/CyclicString.h"
 #include "string/Epsilon.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -18,9 +19,9 @@ int ExactCompare::compare ( const string::String & u, const string::String & v )
 	return dispatch ( u.getData ( ), v.getData ( ) );
 }
 
-auto ExactCompareEpsilon = ExactCompare::RegistratorWrapper < int, string::Epsilon < > > ( ExactCompare::compare );
-auto ExactCompareLinearString = ExactCompare::RegistratorWrapper < int, string::LinearString < > > ( ExactCompare::compare );
-auto ExactCompareCyclicString = ExactCompare::RegistratorWrapper < int, string::CyclicString < > > ( ExactCompare::compare );
+auto ExactCompareEpsilon = registration::OverloadRegister < ExactCompare, int, string::Epsilon < > > ( ExactCompare::compare );
+auto ExactCompareLinearString = registration::OverloadRegister < ExactCompare, int, string::LinearString < > > ( ExactCompare::compare );
+auto ExactCompareCyclicString = registration::OverloadRegister < ExactCompare, int, string::CyclicString < > > ( ExactCompare::compare );
 
 } /* namespace naive */
 
diff --git a/alib2algo/src/string/naive/ExactEqual.cpp b/alib2algo/src/string/naive/ExactEqual.cpp
index c732935b86d7bcb5e51ac413e30f668131b9863a..1ad6e5a90f33c8092c52847db593bdc504bf1c85 100644
--- a/alib2algo/src/string/naive/ExactEqual.cpp
+++ b/alib2algo/src/string/naive/ExactEqual.cpp
@@ -9,6 +9,7 @@
 #include "string/LinearString.h"
 #include "string/CyclicString.h"
 #include "string/Epsilon.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -18,9 +19,9 @@ bool ExactEqual::equals ( const string::String & u, const string::String & v ) {
 	return dispatch ( u.getData ( ), v.getData ( ) );
 }
 
-auto ExactEqualEpsilon = ExactEqual::RegistratorWrapper < bool, string::Epsilon < > > ( ExactEqual::equals );
-auto ExactEqualLinearString = ExactEqual::RegistratorWrapper < bool, string::LinearString < > > ( ExactEqual::equals );
-auto ExactEqualCyclicString = ExactEqual::RegistratorWrapper < bool, string::CyclicString < > > ( ExactEqual::equals );
+auto ExactEqualEpsilon = registration::OverloadRegister < ExactEqual, bool, string::Epsilon < > > ( ExactEqual::equals );
+auto ExactEqualLinearString = registration::OverloadRegister < ExactEqual, bool, string::LinearString < > > ( ExactEqual::equals );
+auto ExactEqualCyclicString = registration::OverloadRegister < ExactEqual, bool, string::CyclicString < > > ( ExactEqual::equals );
 
 } /* namespace naive */
 
diff --git a/alib2algo/src/string/properties/BadCharacterShiftTable.cpp b/alib2algo/src/string/properties/BadCharacterShiftTable.cpp
index 2ce43f29d3a78bbcc45d0519bbe6ef80b14c0f23..0237803dcadae91f10c1119d12c13a2652c2275e 100644
--- a/alib2algo/src/string/properties/BadCharacterShiftTable.cpp
+++ b/alib2algo/src/string/properties/BadCharacterShiftTable.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BadCharacterShiftTable.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ std::map<DefaultSymbolType, size_t> BadCharacterShiftTable::bcs(const string::St
 	return dispatch(pattern.getData());
 }
 
-auto BadCharacterShiftTableLinearString = BadCharacterShiftTable::RegistratorWrapper<std::map<DefaultSymbolType, size_t>, string::LinearString < >>(BadCharacterShiftTable::bcs);
+auto BadCharacterShiftTableLinearString = registration::OverloadRegister < BadCharacterShiftTable, std::map < DefaultSymbolType, size_t >, string::LinearString < > > ( BadCharacterShiftTable::bcs );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/string/properties/BorderArray.cpp b/alib2algo/src/string/properties/BorderArray.cpp
index da63c9319f5a1fe8734d567543ecaf4f316b5015..167c4b7676368e7d442b9e2661897c4c5561b600 100644
--- a/alib2algo/src/string/properties/BorderArray.cpp
+++ b/alib2algo/src/string/properties/BorderArray.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BorderArray.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ std::vector<unsigned> BorderArray::construct(const string::String& string) {
 	return dispatch(string.getData());
 }
 
-auto BorderArrayLinearString = BorderArray::RegistratorWrapper<std::vector<unsigned>, string::LinearString < >>(BorderArray::construct);
+auto BorderArrayLinearString = registration::OverloadRegister < BorderArray, std::vector < unsigned >, string::LinearString < > > ( BorderArray::construct );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/string/properties/GoodSuffixShiftTable.cpp b/alib2algo/src/string/properties/GoodSuffixShiftTable.cpp
index 9d6cd1026fab3905832ad20deffd57e36a556316..48970cc1e60440d42e4838347cbf18ed2ebf5237 100644
--- a/alib2algo/src/string/properties/GoodSuffixShiftTable.cpp
+++ b/alib2algo/src/string/properties/GoodSuffixShiftTable.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "GoodSuffixShiftTable.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ std::vector < size_t > GoodSuffixShiftTable::gss ( const string::String & patter
 	return dispatch ( pattern.getData ( ) );
 }
 
-auto GoodSuffixShiftTableLinearString = GoodSuffixShiftTable::RegistratorWrapper < std::vector < size_t >, string::LinearString < > > ( GoodSuffixShiftTable::gss );
+auto GoodSuffixShiftTableLinearString = registration::OverloadRegister < GoodSuffixShiftTable, std::vector < size_t >, string::LinearString < > > ( GoodSuffixShiftTable::gss );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/string/properties/ReversedBadCharacterShiftTable.cpp b/alib2algo/src/string/properties/ReversedBadCharacterShiftTable.cpp
index 640fb26e9609d318de14237f777886f8e8ebfdd5..295d9862cee23513659c1e4106e8ac4b632f2362 100644
--- a/alib2algo/src/string/properties/ReversedBadCharacterShiftTable.cpp
+++ b/alib2algo/src/string/properties/ReversedBadCharacterShiftTable.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReversedBadCharacterShiftTable.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ std::map < DefaultSymbolType, size_t > ReversedBadCharacterShiftTable::bcs ( con
 	return dispatch ( pattern.getData ( ) );
 }
 
-auto ReversedBadCharacterShiftTableLinearString = ReversedBadCharacterShiftTable::RegistratorWrapper < std::map < DefaultSymbolType, size_t >, string::LinearString < > > ( ReversedBadCharacterShiftTable::bcs );
+auto ReversedBadCharacterShiftTableLinearString = registration::OverloadRegister < ReversedBadCharacterShiftTable, std::map < DefaultSymbolType, size_t >, string::LinearString < > > ( ReversedBadCharacterShiftTable::bcs );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/string/simplify/NormalizeAlphabet.cpp b/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
index c70d1436c8c8184939f6fa495db4579fbe2477bf..595a4cafc90c5231e759bb75557256e32ae39295 100644
--- a/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
+++ b/alib2algo/src/string/simplify/NormalizeAlphabet.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "NormalizeAlphabet.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ string::String NormalizeAlphabet::normalize(const string::String& string) {
 	return dispatch(string.getData());
 }
 
-auto NormalizeAlphabetLinearString = NormalizeAlphabet::RegistratorWrapper<string::LinearString < >, string::LinearString < >>(NormalizeAlphabet::normalize);
+auto NormalizeAlphabetLinearString = registration::OverloadRegister < NormalizeAlphabet, string::LinearString < >, string::LinearString < > > ( NormalizeAlphabet::normalize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/string/simplify/NormalizeRotation.cpp b/alib2algo/src/string/simplify/NormalizeRotation.cpp
index db2c2c689f975561026d9d82b051d173eb58ed9b..18d24531aa3ac213879786bb1731b8f88cda52d5 100644
--- a/alib2algo/src/string/simplify/NormalizeRotation.cpp
+++ b/alib2algo/src/string/simplify/NormalizeRotation.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "NormalizeRotation.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace string {
 
@@ -15,7 +16,7 @@ string::String NormalizeRotation::normalize(const string::String& string) {
 	return dispatch(string.getData());
 }
 
-auto NormalizeRotationCyclicString = NormalizeRotation::RegistratorWrapper<string::CyclicString < >, string::CyclicString < >>(NormalizeRotation::normalize);
+auto NormalizeRotationCyclicString = registration::OverloadRegister < NormalizeRotation, string::CyclicString < >, string::CyclicString < > > ( NormalizeRotation::normalize );
 
 } /* namespace simplify */
 
diff --git a/alib2algo/src/stringology/exact/BoyerMoore.cpp b/alib2algo/src/stringology/exact/BoyerMoore.cpp
index 3b51d1958efbb4bb9daf0874f104d9728febc507..567785fe90952f8171e025988f306a2d5a4a46c5 100644
--- a/alib2algo/src/stringology/exact/BoyerMoore.cpp
+++ b/alib2algo/src/stringology/exact/BoyerMoore.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BoyerMoore.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ std::set<unsigned> BoyerMoore::match(const string::String& subject, const string
 	return dispatch(subject.getData(), pattern.getData());
 }
 
-auto BoyerMooreLinearStringLinearString = BoyerMoore::RegistratorWrapper<std::set<unsigned>, string::LinearString < >, string::LinearString < >>(BoyerMoore::match);
+auto BoyerMooreLinearStringLinearString = registration::OverloadRegister < BoyerMoore, std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( BoyerMoore::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/stringology/exact/BoyerMooreHorspool.cpp b/alib2algo/src/stringology/exact/BoyerMooreHorspool.cpp
index 71d1eeb5068eec64621d8bc5fb691d9d46f01dc3..0edac2ab71e51987976811b06b845756cf48b7de 100644
--- a/alib2algo/src/stringology/exact/BoyerMooreHorspool.cpp
+++ b/alib2algo/src/stringology/exact/BoyerMooreHorspool.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BoyerMooreHorspool.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ std::set<unsigned> BoyerMooreHorspool::match(const string::String& subject, cons
 	return dispatch(subject.getData(), pattern.getData());
 }
 
-auto BoyerMooreHorspoolLinearStringLinearString = BoyerMooreHorspool::RegistratorWrapper<std::set<unsigned>, string::LinearString < >, string::LinearString < >>(BoyerMooreHorspool::match);
+auto BoyerMooreHorspoolLinearStringLinearString = registration::OverloadRegister < BoyerMooreHorspool, std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( BoyerMooreHorspool::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/stringology/exact/DeadZoneUsingBadCharacterShift.cpp b/alib2algo/src/stringology/exact/DeadZoneUsingBadCharacterShift.cpp
index 5006c77bc4c7dc319185a1548b8cbad0bc45ab71..1e065c73b310ac4055867cf326f0cf4c7a4d7872 100644
--- a/alib2algo/src/stringology/exact/DeadZoneUsingBadCharacterShift.cpp
+++ b/alib2algo/src/stringology/exact/DeadZoneUsingBadCharacterShift.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "DeadZoneUsingBadCharacterShift.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ std::set < unsigned > DeadZoneUsingBadCharacterShift::match ( const string::Stri
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto DeadZoneUsingBadCharacterShiftLinearStringLinearString = DeadZoneUsingBadCharacterShift::RegistratorWrapper < std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( DeadZoneUsingBadCharacterShift::match );
+auto DeadZoneUsingBadCharacterShiftLinearStringLinearString = registration::OverloadRegister < DeadZoneUsingBadCharacterShift, std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( DeadZoneUsingBadCharacterShift::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/stringology/exact/ExactFactorMatch.cpp b/alib2algo/src/stringology/exact/ExactFactorMatch.cpp
index 3ad442f933086939245aff1429bfab408e535711..265cbf8c882408e8ee0cc2f88e875561e2ee827f 100644
--- a/alib2algo/src/stringology/exact/ExactFactorMatch.cpp
+++ b/alib2algo/src/stringology/exact/ExactFactorMatch.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ExactFactorMatch.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ std::set < unsigned > ExactFactorMatch::match ( const string::String & subject,
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto ExactFactorMatchLinearString = ExactFactorMatch::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( ExactFactorMatch::match );
+auto ExactFactorMatchLinearString = registration::OverloadRegister < ExactFactorMatch, std::set < unsigned >, string::LinearString < > > ( ExactFactorMatch::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/stringology/exact/ReversedBoyerMooreHorspool.cpp b/alib2algo/src/stringology/exact/ReversedBoyerMooreHorspool.cpp
index 6b6d1d8804790bd9297ba798f3483809da33db6d..57358def6e36c5f2a8642e55ec943d7b31d2d44e 100644
--- a/alib2algo/src/stringology/exact/ReversedBoyerMooreHorspool.cpp
+++ b/alib2algo/src/stringology/exact/ReversedBoyerMooreHorspool.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReversedBoyerMooreHorspool.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ std::set < unsigned > ReversedBoyerMooreHorspool::match ( const string::String &
 	return dispatch ( subject.getData ( ), pattern.getData ( ) );
 }
 
-auto ReversedBoyerMooreHorpoolLinearStringLinearString = ReversedBoyerMooreHorspool::RegistratorWrapper < std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( ReversedBoyerMooreHorspool::match );
+auto ReversedBoyerMooreHorpoolLinearStringLinearString = registration::OverloadRegister < ReversedBoyerMooreHorspool, std::set < unsigned >, string::LinearString < >, string::LinearString < > > ( ReversedBoyerMooreHorspool::match );
 
 } /* namespace exact */
 
diff --git a/alib2algo/src/stringology/indexing/BitParallelIndexConstruction.cpp b/alib2algo/src/stringology/indexing/BitParallelIndexConstruction.cpp
index ab1944e02b697879973a41304b3eef8764f37967..0ff8dbd6261ce4632f8c2b2b43e6a7f58e98dffe 100644
--- a/alib2algo/src/stringology/indexing/BitParallelIndexConstruction.cpp
+++ b/alib2algo/src/stringology/indexing/BitParallelIndexConstruction.cpp
@@ -8,6 +8,7 @@
 #include "BitParallelIndexConstruction.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::BitParallelIndex < DefaultSymbolType > BitParallelIndexCon
 	return dispatch ( string.getData ( ) );
 }
 
-auto bitParallelIndexConstructionLinearString = BitParallelIndexConstruction::RegistratorWrapper < indexes::stringology::BitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( BitParallelIndexConstruction::construct );
+auto bitParallelIndexConstructionLinearString = registration::OverloadRegister < BitParallelIndexConstruction, indexes::stringology::BitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( BitParallelIndexConstruction::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/CompressedBitParallelIndexConstruction.cpp b/alib2algo/src/stringology/indexing/CompressedBitParallelIndexConstruction.cpp
index d88f00999c7374c29398b83d66212dbdd4c11d69..1621e935b0d1cfb6ba85b3306a159e7c9eb0073d 100644
--- a/alib2algo/src/stringology/indexing/CompressedBitParallelIndexConstruction.cpp
+++ b/alib2algo/src/stringology/indexing/CompressedBitParallelIndexConstruction.cpp
@@ -8,6 +8,7 @@
 #include "CompressedBitParallelIndexConstruction.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::CompressedBitParallelIndex < DefaultSymbolType > Compresse
 	return dispatch ( string.getData ( ) );
 }
 
-auto compressedCompressedBitParallelIndexConstructionLinearString = CompressedBitParallelIndexConstruction::RegistratorWrapper < indexes::stringology::CompressedBitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( CompressedBitParallelIndexConstruction::construct );
+auto compressedCompressedBitParallelIndexConstructionLinearString = registration::OverloadRegister < CompressedBitParallelIndexConstruction, indexes::stringology::CompressedBitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( CompressedBitParallelIndexConstruction::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/ExactFactorOracleAutomaton.cpp b/alib2algo/src/stringology/indexing/ExactFactorOracleAutomaton.cpp
index 459e1325d77fbb27c10f412ee8c7cfce9e3bb60a..63ba8fdf81586b304e635e09e5e1c59b7c65fa77 100644
--- a/alib2algo/src/stringology/indexing/ExactFactorOracleAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/ExactFactorOracleAutomaton.cpp
@@ -4,6 +4,7 @@
 
 #include "ExactFactorOracleAutomaton.h"
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -53,7 +54,7 @@ void ExactFactorOracleAutomaton::oracleAddLetter ( automaton::DFA < > & oracle,
 	supplyFunction.insert( { newState, supplyState } );
 }
 
-auto FactorOracleAutomatonLinearString = ExactFactorOracleAutomaton::RegistratorWrapper < automaton::DFA < >, string::LinearString < > > ( ExactFactorOracleAutomaton::construct );
+auto FactorOracleAutomatonLinearString = registration::OverloadRegister < ExactFactorOracleAutomaton, automaton::DFA < >, string::LinearString < > > ( ExactFactorOracleAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/ExactNondeterministicSubsequenceAutomaton.cpp b/alib2algo/src/stringology/indexing/ExactNondeterministicSubsequenceAutomaton.cpp
index feb46bf22cba7bd4d06b4ac22ec8222d30a7b29b..7a0c25b44b535d0d6e693785838821094d625a12 100644
--- a/alib2algo/src/stringology/indexing/ExactNondeterministicSubsequenceAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/ExactNondeterministicSubsequenceAutomaton.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ExactNondeterministicSubsequenceAutomaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ automaton::Automaton ExactNondeterministicSubsequenceAutomaton::construct(const
 	return dispatch(text.getData());
 }
 
-auto ExactNondeterministicSubsequenceAutomatonLinearString = ExactNondeterministicSubsequenceAutomaton::RegistratorWrapper < automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > > ( ExactNondeterministicSubsequenceAutomaton::construct );
+auto ExactNondeterministicSubsequenceAutomatonLinearString = registration::OverloadRegister < ExactNondeterministicSubsequenceAutomaton, automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > > ( ExactNondeterministicSubsequenceAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/ExactSubsequenceAutomaton.cpp b/alib2algo/src/stringology/indexing/ExactSubsequenceAutomaton.cpp
index 3da7a3dcd37ef017ed80cd3749abc8ee3b548e6e..185498842f1bdf76e39251a6e31008f4b4892f73 100644
--- a/alib2algo/src/stringology/indexing/ExactSubsequenceAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/ExactSubsequenceAutomaton.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ExactSubsequenceAutomaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ automaton::Automaton ExactSubsequenceAutomaton::construct(const string::String&
 	return dispatch(text.getData());
 }
 
-auto ExactSubsequenceAutomatonLinearString = ExactSubsequenceAutomaton::RegistratorWrapper < automaton::DFA < DefaultSymbolType, unsigned >, string::LinearString < > > ( ExactSubsequenceAutomaton::construct );
+auto ExactSubsequenceAutomatonLinearString = registration::OverloadRegister < ExactSubsequenceAutomaton, automaton::DFA < DefaultSymbolType, unsigned >, string::LinearString < > > ( ExactSubsequenceAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/ExactSuffixAutomaton.cpp b/alib2algo/src/stringology/indexing/ExactSuffixAutomaton.cpp
index 15d808a8a807863480a9df8e89e77073509519bc..59f5f5706a10b1cef479169f366180e40a397f5d 100644
--- a/alib2algo/src/stringology/indexing/ExactSuffixAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/ExactSuffixAutomaton.cpp
@@ -3,6 +3,7 @@
  */
 
 #include "ExactSuffixAutomaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -81,7 +82,7 @@ void ExactSuffixAutomaton::suffixAutomatonAddSymbol ( automaton::DFA < > & suffi
 	lastState = newState;
 }
 
-auto SuffixAutomatonLinearString = ExactSuffixAutomaton::RegistratorWrapper < automaton::DFA < >, string::LinearString < > > ( ExactSuffixAutomaton::construct );
+auto SuffixAutomatonLinearString = registration::OverloadRegister < ExactSuffixAutomaton, automaton::DFA < >, string::LinearString < > > ( ExactSuffixAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/NondeterministicExactFactorAutomaton.cpp b/alib2algo/src/stringology/indexing/NondeterministicExactFactorAutomaton.cpp
index 0fa8a91dc28fc924db31b40bd0bb4534294457f4..ca86dc7c6d6924d0d48051d9698d528ada1356eb 100644
--- a/alib2algo/src/stringology/indexing/NondeterministicExactFactorAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/NondeterministicExactFactorAutomaton.cpp
@@ -10,6 +10,7 @@
 #include <string/Epsilon.h>
 
 #include <deque>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -19,7 +20,7 @@ automaton::Automaton NondeterministicExactFactorAutomaton::construct(const strin
 	return dispatch(text.getData());
 }
 
-auto ExactFactorAutomatonLinearString = NondeterministicExactFactorAutomaton::RegistratorWrapper<automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > >(NondeterministicExactFactorAutomaton::construct);
+auto ExactFactorAutomatonLinearString = registration::OverloadRegister < NondeterministicExactFactorAutomaton, automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > > ( NondeterministicExactFactorAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/NondeterministicExactSuffixAutomaton.cpp b/alib2algo/src/stringology/indexing/NondeterministicExactSuffixAutomaton.cpp
index fa825f6d395e27da42aa9f56113fd747f552e9f6..9e387658c1e13f9806d27fab2d3619bcfd135198 100644
--- a/alib2algo/src/stringology/indexing/NondeterministicExactSuffixAutomaton.cpp
+++ b/alib2algo/src/stringology/indexing/NondeterministicExactSuffixAutomaton.cpp
@@ -3,6 +3,7 @@
  */
 
 #include "NondeterministicExactSuffixAutomaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -29,7 +30,7 @@ automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned > Nondet
 	return nfaSuffixAutomaton;
 }
 
-auto SuffixAutomatonNondeterministicLinearString = NondeterministicExactSuffixAutomaton::RegistratorWrapper < automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > > ( NondeterministicExactSuffixAutomaton::construct );
+auto SuffixAutomatonNondeterministicLinearString = registration::OverloadRegister < NondeterministicExactSuffixAutomaton, automaton::EpsilonNFA < DefaultSymbolType, DefaultEpsilonType, unsigned >, string::LinearString < > > ( NondeterministicExactSuffixAutomaton::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/PositionHeapNaive.cpp b/alib2algo/src/stringology/indexing/PositionHeapNaive.cpp
index 0cf33b496851a0a3a5de01fe121b1203184226f6..e9dc4ffbfa2f31e6304ec3c60df8b2b8959cc31f 100644
--- a/alib2algo/src/stringology/indexing/PositionHeapNaive.cpp
+++ b/alib2algo/src/stringology/indexing/PositionHeapNaive.cpp
@@ -8,6 +8,7 @@
 #include "PositionHeapNaive.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::PositionHeap < DefaultSymbolType > PositionHeapNaive::cons
 	return dispatch ( string.getData ( ) );
 }
 
-auto positionHeapNaiveLinearString = PositionHeapNaive::RegistratorWrapper < indexes::stringology::PositionHeap < DefaultSymbolType >, string::LinearString < > > ( PositionHeapNaive::construct );
+auto positionHeapNaiveLinearString = registration::OverloadRegister < PositionHeapNaive, indexes::stringology::PositionHeap < DefaultSymbolType >, string::LinearString < > > ( PositionHeapNaive::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/SuffixArrayNaive.cpp b/alib2algo/src/stringology/indexing/SuffixArrayNaive.cpp
index b003e712e09cba1b4df59b39061104604abca7e6..4a4d26a02c2aa6b1bad579bf51d416b78ec3dad8 100644
--- a/alib2algo/src/stringology/indexing/SuffixArrayNaive.cpp
+++ b/alib2algo/src/stringology/indexing/SuffixArrayNaive.cpp
@@ -8,6 +8,7 @@
 #include "SuffixArrayNaive.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::SuffixArray < > SuffixArrayNaive::construct ( const string
 	return dispatch ( string.getData ( ) );
 }
 
-auto suffixArrayNaiveLinearString = SuffixArrayNaive::RegistratorWrapper < indexes::stringology::SuffixArray < >, string::LinearString < > > ( SuffixArrayNaive::construct );
+auto suffixArrayNaiveLinearString = registration::OverloadRegister < SuffixArrayNaive, indexes::stringology::SuffixArray < >, string::LinearString < > > ( SuffixArrayNaive::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/indexing/SuffixTrieNaive.cpp b/alib2algo/src/stringology/indexing/SuffixTrieNaive.cpp
index c5bb33a5a70d21b1833579d674d219f7fe75cf86..82aa80eb7fc394b672e26297696908a971d4a7e5 100644
--- a/alib2algo/src/stringology/indexing/SuffixTrieNaive.cpp
+++ b/alib2algo/src/stringology/indexing/SuffixTrieNaive.cpp
@@ -8,6 +8,7 @@
 #include "SuffixTrieNaive.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::SuffixTrie < DefaultSymbolType > SuffixTrieNaive::construc
 	return dispatch ( string.getData ( ) );
 }
 
-auto suffixTrieNaiveLinearString = SuffixTrieNaive::RegistratorWrapper < indexes::stringology::SuffixTrie < DefaultSymbolType >, string::LinearString < > > ( SuffixTrieNaive::construct );
+auto suffixTrieNaiveLinearString = registration::OverloadRegister < SuffixTrieNaive, indexes::stringology::SuffixTrie < DefaultSymbolType >, string::LinearString < > > ( SuffixTrieNaive::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2algo/src/stringology/matching/BNDMMatcherConstruction.cpp b/alib2algo/src/stringology/matching/BNDMMatcherConstruction.cpp
index 01c752df57837288d4f6e3d0d42db5f584445023..30e4712a7e7c36b12b212d360f8fb1b76ac90eb5 100644
--- a/alib2algo/src/stringology/matching/BNDMMatcherConstruction.cpp
+++ b/alib2algo/src/stringology/matching/BNDMMatcherConstruction.cpp
@@ -8,6 +8,7 @@
 #include "BNDMMatcherConstruction.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::BNDMMatcher < DefaultSymbolType > BNDMMatcherConstruction:
 	return dispatch ( string.getData ( ) );
 }
 
-auto BNDMIndexConstructionLinearString = BNDMMatcherConstruction::RegistratorWrapper < indexes::stringology::BNDMMatcher < >, string::LinearString < > > ( BNDMMatcherConstruction::construct );
+auto BNDMIndexConstructionLinearString = registration::OverloadRegister < BNDMMatcherConstruction, indexes::stringology::BNDMMatcher < >, string::LinearString < > > ( BNDMMatcherConstruction::construct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/matching/DAWGMatcherConstruction.cpp b/alib2algo/src/stringology/matching/DAWGMatcherConstruction.cpp
index 1a5268690eaec6b7585f0bee5ff5dcd6c24016f7..3ed8a2c25aad8247dc90d46f4c89e0213f340882 100644
--- a/alib2algo/src/stringology/matching/DAWGMatcherConstruction.cpp
+++ b/alib2algo/src/stringology/matching/DAWGMatcherConstruction.cpp
@@ -4,6 +4,7 @@
 
 #include "DAWGMatcherConstruction.h"
 #include <stringology/indexing/ExactSuffixAutomaton.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -21,7 +22,7 @@ automaton::DFA < > DAWGMatcherConstruction::construct ( const string::LinearStri
 	return stringology::indexing::ExactSuffixAutomaton::construct ( reversedPattern );
 }
 
-auto DAWGMatcherConstructionLinearString = DAWGMatcherConstruction::RegistratorWrapper < automaton::DFA < >, string::LinearString < > > ( DAWGMatcherConstruction::construct );
+auto DAWGMatcherConstructionLinearString = registration::OverloadRegister < DAWGMatcherConstruction, automaton::DFA < >, string::LinearString < > > ( DAWGMatcherConstruction::construct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/matching/ExactMatchingAutomaton.cpp b/alib2algo/src/stringology/matching/ExactMatchingAutomaton.cpp
index f7114e25c5b8a146d57338d429aab1556a58c4ea..d176d0833719b2084a89298c4627cb1968edd522 100644
--- a/alib2algo/src/stringology/matching/ExactMatchingAutomaton.cpp
+++ b/alib2algo/src/stringology/matching/ExactMatchingAutomaton.cpp
@@ -10,6 +10,7 @@
 #include <string/Epsilon.h>
 
 #include <deque>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -19,7 +20,7 @@ automaton::Automaton ExactMatchingAutomaton::construct(const string::String& pat
 	return dispatch(pattern.getData());
 }
 
-auto ExactMatchingAutomatonLinearString = ExactMatchingAutomaton::RegistratorWrapper<automaton::NFA < DefaultSymbolType, unsigned > , string::LinearString < > >(ExactMatchingAutomaton::construct);
+auto ExactMatchingAutomatonLinearString = registration::OverloadRegister < ExactMatchingAutomaton, automaton::NFA < DefaultSymbolType, unsigned >, string::LinearString < > > ( ExactMatchingAutomaton::construct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/matching/NaiveDAWGMatcherConstruction.cpp b/alib2algo/src/stringology/matching/NaiveDAWGMatcherConstruction.cpp
index c9f139a74279f500e2da0d1e4b000b23fa07d107..8812888071f986a1e0ddba8c13b7b8b789e23e18 100644
--- a/alib2algo/src/stringology/matching/NaiveDAWGMatcherConstruction.cpp
+++ b/alib2algo/src/stringology/matching/NaiveDAWGMatcherConstruction.cpp
@@ -7,6 +7,7 @@
 #include <automaton/simplify/Minimize.h>
 #include <automaton/simplify/EpsilonRemoverIncoming.h>
 #include <stringology/indexing/NondeterministicExactSuffixAutomaton.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -27,7 +28,7 @@ automaton::DFA < DefaultSymbolType, std::set < unsigned > > NaiveDAWGMatcherCons
 
 }
 
-auto NaiveDAWGMatcherConstructionLinearString = NaiveDAWGMatcherConstruction::RegistratorWrapper < automaton::DFA < DefaultSymbolType, std::set < unsigned > >, string::LinearString < > > ( NaiveDAWGMatcherConstruction::naiveConstruct );
+auto NaiveDAWGMatcherConstructionLinearString = registration::OverloadRegister < NaiveDAWGMatcherConstruction, automaton::DFA < DefaultSymbolType, std::set < unsigned > >, string::LinearString < > > ( NaiveDAWGMatcherConstruction::naiveConstruct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/matching/OracleMatcherConstruction.cpp b/alib2algo/src/stringology/matching/OracleMatcherConstruction.cpp
index aa9b1f24dd03e7e317976bdc4a0d95c468089402..c345342bdcfd7781b0a6f7eb776bc475c126da54 100644
--- a/alib2algo/src/stringology/matching/OracleMatcherConstruction.cpp
+++ b/alib2algo/src/stringology/matching/OracleMatcherConstruction.cpp
@@ -4,6 +4,7 @@
 
 #include "OracleMatcherConstruction.h"
 #include <stringology/indexing/ExactSuffixAutomaton.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -21,7 +22,7 @@ automaton::DFA < > OracleMatcherConstruction::construct ( const string::LinearSt
 	return stringology::indexing::ExactSuffixAutomaton::construct ( reversedPattern );
 }
 
-auto OracleMatcherConstructionLinearString = OracleMatcherConstruction::RegistratorWrapper < automaton::DFA < >, string::LinearString < > > ( OracleMatcherConstruction::construct );
+auto OracleMatcherConstructionLinearString = registration::OverloadRegister < OracleMatcherConstruction, automaton::DFA < >, string::LinearString < > > ( OracleMatcherConstruction::construct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/matching/WideBNDMMatcherConstruction.cpp b/alib2algo/src/stringology/matching/WideBNDMMatcherConstruction.cpp
index 1357d72957d95fcf0f117656d4cd0635291230f6..5231f71f0c54d35a6a65d3c4041b1cdf01126bc1 100644
--- a/alib2algo/src/stringology/matching/WideBNDMMatcherConstruction.cpp
+++ b/alib2algo/src/stringology/matching/WideBNDMMatcherConstruction.cpp
@@ -8,6 +8,7 @@
 #include "WideBNDMMatcherConstruction.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ indexes::stringology::BitParallelIndex < DefaultSymbolType > WideBNDMMatcherCons
 	return dispatch ( string.getData ( ) );
 }
 
-auto WideBNDMIndexConstructionLinearString = WideBNDMMatcherConstruction::RegistratorWrapper < indexes::stringology::BitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( WideBNDMMatcherConstruction::construct );
+auto WideBNDMIndexConstructionLinearString = registration::OverloadRegister < WideBNDMMatcherConstruction, indexes::stringology::BitParallelIndex < DefaultSymbolType >, string::LinearString < > > ( WideBNDMMatcherConstruction::construct );
 
 } /* namespace matching */
 
diff --git a/alib2algo/src/stringology/properties/BackboneLength.cpp b/alib2algo/src/stringology/properties/BackboneLength.cpp
index f1f9f2d3dea3d566ffae906bdacddaa3c0e5f886..25189e865a1efa5e3fd222d85788aa1d1d6ab017 100644
--- a/alib2algo/src/stringology/properties/BackboneLength.cpp
+++ b/alib2algo/src/stringology/properties/BackboneLength.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BackboneLength.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -15,7 +16,7 @@ unsigned BackboneLength::length ( const automaton::Automaton & automaton ) {
 	return dispatch ( automaton.getData ( ) );
 }
 
-auto backboneLengthDFA = BackboneLength::RegistratorWrapper < unsigned, automaton::DFA < > > ( BackboneLength::length );
+auto backboneLengthDFA = registration::OverloadRegister < BackboneLength, unsigned, automaton::DFA < > > ( BackboneLength::length );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/stringology/query/BNDMOccurrences.cpp b/alib2algo/src/stringology/query/BNDMOccurrences.cpp
index d184d80aa44c56f1db17211cfde2fe11f792a96a..fa0e65f7762121526aecd7cd403de0efdd941c9e 100644
--- a/alib2algo/src/stringology/query/BNDMOccurrences.cpp
+++ b/alib2algo/src/stringology/query/BNDMOccurrences.cpp
@@ -8,6 +8,7 @@
 #include "BNDMOccurrences.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > BNDMOccurrences::query ( const indexes::stringology::BNDMM
 	return dispatch ( pattern, subject.getData ( ) );
 }
 
-auto bndmOccurrencesLinearString = BNDMOccurrences::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( BNDMOccurrences::query );
+auto bndmOccurrencesLinearString = registration::OverloadRegister < BNDMOccurrences, std::set < unsigned >, string::LinearString < > > ( BNDMOccurrences::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/BackwardDAWGMatching.cpp b/alib2algo/src/stringology/query/BackwardDAWGMatching.cpp
index e93db0dd563919f0bdcfb8ae88f0fee53a81a95b..8f075f3eae49a46e1ddab29a26c64c37303b1fd9 100644
--- a/alib2algo/src/stringology/query/BackwardDAWGMatching.cpp
+++ b/alib2algo/src/stringology/query/BackwardDAWGMatching.cpp
@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <map>
 #include <measure>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -62,7 +63,7 @@ std::set < unsigned > BackwardDAWGMatching::match ( const string::LinearString <
 	return occ;
 }
 
-auto BackwardDAWGMatchingLinearStringLinearString = BackwardDAWGMatching::RegistratorWrapper < std::set < unsigned >, string::LinearString < >, automaton::DFA < > > ( BackwardDAWGMatching::match );
+auto BackwardDAWGMatchingLinearStringLinearString = registration::OverloadRegister < BackwardDAWGMatching, std::set < unsigned >, string::LinearString < >, automaton::DFA < > > ( BackwardDAWGMatching::match );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/BackwardOracleMatching.cpp b/alib2algo/src/stringology/query/BackwardOracleMatching.cpp
index 57da6ea3b5bef4840f0d9161a55e6d22d89dfd97..a4f6b3922206c4c27ac6616b01e5b44decd58b85 100644
--- a/alib2algo/src/stringology/query/BackwardOracleMatching.cpp
+++ b/alib2algo/src/stringology/query/BackwardOracleMatching.cpp
@@ -12,6 +12,7 @@
 #include <algorithm>
 #include <map>
 #include <measure>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -58,7 +59,7 @@ std::set < unsigned > BackwardOracleMatching::match ( const string::LinearString
 	return occ;
 }
 
-auto BackwardOracleMatchingLinearStringLinearString = BackwardOracleMatching::RegistratorWrapper < std::set < unsigned >, string::LinearString < >, automaton::DFA < > > ( BackwardOracleMatching::match );
+auto BackwardOracleMatchingLinearStringLinearString = registration::OverloadRegister < BackwardOracleMatching, std::set < unsigned >, string::LinearString < >, automaton::DFA < > > ( BackwardOracleMatching::match );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/BitParallelismFactors.cpp b/alib2algo/src/stringology/query/BitParallelismFactors.cpp
index d2eb2f41cf125577bb93b1bbdc0bb0a9306e24d8..80720e9a334572007b29de81c2d21f5353d2e1a4 100644
--- a/alib2algo/src/stringology/query/BitParallelismFactors.cpp
+++ b/alib2algo/src/stringology/query/BitParallelismFactors.cpp
@@ -8,6 +8,7 @@
 #include "BitParallelismFactors.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > BitParallelismFactors::query ( const indexes::stringology:
 	return dispatch ( bitParallelIndex, string.getData ( ) );
 }
 
-auto BitParallelismFactorsLinearString = BitParallelismFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( BitParallelismFactors::query );
+auto BitParallelismFactorsLinearString = registration::OverloadRegister < BitParallelismFactors, std::set < unsigned >, string::LinearString < > > ( BitParallelismFactors::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/CompressedBitParallelismFactors.cpp b/alib2algo/src/stringology/query/CompressedBitParallelismFactors.cpp
index d1eea5dd839ce1123100ff26a45037e980273117..14e50e1b31ae2e0aed7fdb077f7aaf819429e232 100644
--- a/alib2algo/src/stringology/query/CompressedBitParallelismFactors.cpp
+++ b/alib2algo/src/stringology/query/CompressedBitParallelismFactors.cpp
@@ -8,6 +8,7 @@
 #include "CompressedBitParallelismFactors.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > CompressedBitParallelismFactors::query ( const indexes::st
 	return dispatch ( compressedBitParallelIndex, string.getData ( ) );
 }
 
-auto CompressedBitParallelismFactorsLinearString = CompressedBitParallelismFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( CompressedBitParallelismFactors::query );
+auto CompressedBitParallelismFactorsLinearString = registration::OverloadRegister < CompressedBitParallelismFactors, std::set < unsigned >, string::LinearString < > > ( CompressedBitParallelismFactors::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/PositionHeapFactors.cpp b/alib2algo/src/stringology/query/PositionHeapFactors.cpp
index ce32e67fca9c841e92630c89f4a1d0bc3f7367d7..2433b6a1ae4e76f35ab284394f7599c2f728efe7 100644
--- a/alib2algo/src/stringology/query/PositionHeapFactors.cpp
+++ b/alib2algo/src/stringology/query/PositionHeapFactors.cpp
@@ -8,6 +8,7 @@
 #include "PositionHeapFactors.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > PositionHeapFactors::query ( const indexes::stringology::P
 	return dispatch ( positionHeap, string.getData ( ) );
 }
 
-auto PositionHeapFactorsLinearString = PositionHeapFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( PositionHeapFactors::query );
+auto PositionHeapFactorsLinearString = registration::OverloadRegister < PositionHeapFactors, std::set < unsigned >, string::LinearString < > > ( PositionHeapFactors::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/SuffixArrayFactors.cpp b/alib2algo/src/stringology/query/SuffixArrayFactors.cpp
index 52d61687c48c15945b9e9992d8c2d4fbf9bd001d..dda1a69ca67e5bb17a61d35815c54562fe7b2ce4 100644
--- a/alib2algo/src/stringology/query/SuffixArrayFactors.cpp
+++ b/alib2algo/src/stringology/query/SuffixArrayFactors.cpp
@@ -8,6 +8,7 @@
 #include "SuffixArrayFactors.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > SuffixArrayFactors::query ( const indexes::stringology::Su
 	return dispatch ( suffixArray, string.getData ( ) );
 }
 
-auto SuffixArrayFactorsLinearString = SuffixArrayFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( SuffixArrayFactors::query );
+auto SuffixArrayFactorsLinearString = registration::OverloadRegister < SuffixArrayFactors, std::set < unsigned >, string::LinearString < > > ( SuffixArrayFactors::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/SuffixTrieFactors.cpp b/alib2algo/src/stringology/query/SuffixTrieFactors.cpp
index c47ad35bd805ab58f2eeecf52a3bcbd558f8943e..4c2fea5f5d098b71994b3271b7f99b96fd965e08 100644
--- a/alib2algo/src/stringology/query/SuffixTrieFactors.cpp
+++ b/alib2algo/src/stringology/query/SuffixTrieFactors.cpp
@@ -8,6 +8,7 @@
 #include "SuffixTrieFactors.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > SuffixTrieFactors::query ( const indexes::stringology::Suf
 	return dispatch ( suffixTrie, string.getData ( ) );
 }
 
-auto SuffixTrieFactorsLinearString = SuffixTrieFactors::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( SuffixTrieFactors::query );
+auto SuffixTrieFactorsLinearString = registration::OverloadRegister < SuffixTrieFactors, std::set < unsigned >, string::LinearString < > > ( SuffixTrieFactors::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/stringology/query/WideBNDMOccurrences.cpp b/alib2algo/src/stringology/query/WideBNDMOccurrences.cpp
index e028f64898ac098e9fdb8c538687a92cf70a0222..c29332bdba36da4fbc2e115c25d89022db09f632 100644
--- a/alib2algo/src/stringology/query/WideBNDMOccurrences.cpp
+++ b/alib2algo/src/stringology/query/WideBNDMOccurrences.cpp
@@ -8,6 +8,7 @@
 #include "WideBNDMOccurrences.h"
 
 #include <string/LinearString.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -17,7 +18,7 @@ std::set < unsigned > WideBNDMOccurrences::query ( const indexes::stringology::B
 	return dispatch ( pattern, subject.getData ( ) );
 }
 
-auto wideBNDMOccurrencesLinearString = WideBNDMOccurrences::RegistratorWrapper < std::set < unsigned >, string::LinearString < > > ( WideBNDMOccurrences::query );
+auto wideBNDMOccurrencesLinearString = registration::OverloadRegister < WideBNDMOccurrences, std::set < unsigned >, string::LinearString < > > ( WideBNDMOccurrences::query );
 
 } /* namespace query */
 
diff --git a/alib2algo/src/tree/NormalizeTreeLabels.cpp b/alib2algo/src/tree/NormalizeTreeLabels.cpp
index 26b509933e4630171d4c1d78e1561f8d5c81b462..ad56aaeeb25fbb78721a5463b7ee43e9066b559d 100644
--- a/alib2algo/src/tree/NormalizeTreeLabels.cpp
+++ b/alib2algo/src/tree/NormalizeTreeLabels.cpp
@@ -7,6 +7,7 @@
 
 #include "NormalizeTreeLabels.h"
 #include <tree/Tree.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -14,6 +15,6 @@ tree::Tree NormalizeTreeLabels::normalize ( const tree::Tree & tree ) {
 	return dispatch ( tree.getData ( ) );
 }
 
-auto NormalizeTreeLabelsRankedTree = NormalizeTreeLabels::RegistratorWrapper < tree::RankedTree < unsigned, DefaultRankType >, tree::RankedTree < > > ( NormalizeTreeLabels::normalize );
+auto NormalizeTreeLabelsRankedTree = registration::OverloadRegister < NormalizeTreeLabels, tree::RankedTree < unsigned, DefaultRankType >, tree::RankedTree < > > ( NormalizeTreeLabels::normalize );
 
 } /* namespace tree */
diff --git a/alib2algo/src/tree/properties/BadCharacterShiftTable.cpp b/alib2algo/src/tree/properties/BadCharacterShiftTable.cpp
index 413c76d9d34581144b9e9d772228076723ab4c70..8ec1c7e51b253dbc0e856c47913b71e2391e0656 100644
--- a/alib2algo/src/tree/properties/BadCharacterShiftTable.cpp
+++ b/alib2algo/src/tree/properties/BadCharacterShiftTable.cpp
@@ -9,6 +9,7 @@
 
 #include <tree/ranked/PrefixRankedBarPattern.h>
 #include <tree/ranked/PrefixRankedBarNonlinearPattern.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -18,8 +19,8 @@ std::map < std::ranked_symbol < >, size_t > BadCharacterShiftTable::bcs ( const
 	return dispatch ( pattern.getData ( ) );
 }
 
-auto BadCharacterShiftTablePrefixRankedBarPattern = BadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarPattern < > > ( BadCharacterShiftTable::bcs );
-auto BadCharacterShiftTablePrefixRankedBarNonlinearPattern = BadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarNonlinearPattern < > > ( BadCharacterShiftTable::bcs );
+auto BadCharacterShiftTablePrefixRankedBarPattern = registration::OverloadRegister < BadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarPattern < > > ( BadCharacterShiftTable::bcs );
+auto BadCharacterShiftTablePrefixRankedBarNonlinearPattern = registration::OverloadRegister < BadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarNonlinearPattern < > > ( BadCharacterShiftTable::bcs );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/tree/properties/BorderArrayNaive.cpp b/alib2algo/src/tree/properties/BorderArrayNaive.cpp
index 8163b735d9add1a0f733ab59e317e5daf000db74..38b4061d2c28e1daefbacc0873d1ec246e34cf39 100644
--- a/alib2algo/src/tree/properties/BorderArrayNaive.cpp
+++ b/alib2algo/src/tree/properties/BorderArrayNaive.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "BorderArrayNaive.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -15,8 +16,8 @@ std::vector < size_t > BorderArrayNaive::ba ( const tree::Tree & pattern ) {
 	return dispatch ( pattern.getData ( ) );
 }
 
-auto BorderArrayPrefixRankedBarPattern = BorderArrayNaive::RegistratorWrapper < std::vector < size_t >, tree::PrefixRankedBarPattern < > > ( BorderArrayNaive::ba );
-auto BorderArrayPrefixRankedPattern = BorderArrayNaive::RegistratorWrapper < std::vector < size_t >, tree::PrefixRankedPattern < > > ( BorderArrayNaive::ba );
+auto BorderArrayPrefixRankedBarPattern = registration::OverloadRegister < BorderArrayNaive, std::vector < size_t >, tree::PrefixRankedBarPattern < > > ( BorderArrayNaive::ba );
+auto BorderArrayPrefixRankedPattern = registration::OverloadRegister < BorderArrayNaive, std::vector < size_t >, tree::PrefixRankedPattern < > > ( BorderArrayNaive::ba );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/tree/properties/ExactSubtreeRepeats.cpp b/alib2algo/src/tree/properties/ExactSubtreeRepeats.cpp
index dbf6c3cd590029b9b0effb7efca9016700e8abef..fda17f58fc5f6009b73b47850ff0b03c9b8ef57d 100644
--- a/alib2algo/src/tree/properties/ExactSubtreeRepeats.cpp
+++ b/alib2algo/src/tree/properties/ExactSubtreeRepeats.cpp
@@ -7,6 +7,7 @@
 
 #include "ExactSubtreeRepeats.h"
 #include <tree/Tree.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -16,7 +17,7 @@ tree::Tree ExactSubtreeRepeats::repeats ( const tree::Tree & tree ) {
 	return dispatch ( tree.getData ( ) );
 }
 
-auto ExactRepeatsPostfixRankedTree = ExactSubtreeRepeats::RegistratorWrapper < tree::PostfixRankedTree < unsigned, DefaultRankType >, tree::PostfixRankedTree < > > ( ExactSubtreeRepeats::repeats );
+auto ExactRepeatsPostfixRankedTree = registration::OverloadRegister < ExactSubtreeRepeats, tree::PostfixRankedTree < unsigned, DefaultRankType >, tree::PostfixRankedTree < > > ( ExactSubtreeRepeats::repeats );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/tree/properties/ExactSubtreeRepeatsNaive.cpp b/alib2algo/src/tree/properties/ExactSubtreeRepeatsNaive.cpp
index 8c8f54745383497d78709d077b37a6a198d99d4c..4f8a62cb2ade118747ff6316d57b6058e03647e6 100644
--- a/alib2algo/src/tree/properties/ExactSubtreeRepeatsNaive.cpp
+++ b/alib2algo/src/tree/properties/ExactSubtreeRepeatsNaive.cpp
@@ -7,6 +7,7 @@
 
 #include "ExactSubtreeRepeatsNaive.h"
 #include <tree/Tree.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -16,10 +17,10 @@ tree::Tree ExactSubtreeRepeatsNaive::repeats ( const tree::Tree & tree ) {
 	return dispatch ( tree.getData ( ) );
 }
 
-auto ExactRepeatsNaiveRankedTree = ExactSubtreeRepeatsNaive::RegistratorWrapper < tree::RankedTree < unsigned, DefaultRankType >, tree::RankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
-auto ExactRepeatsNaivePrefixRankedTree = ExactSubtreeRepeatsNaive::RegistratorWrapper < tree::PrefixRankedTree < unsigned, DefaultRankType >, tree::PrefixRankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
-auto ExactRepeatsNaivePostfixRankedTree = ExactSubtreeRepeatsNaive::RegistratorWrapper < tree::PostfixRankedTree < unsigned, DefaultRankType >, tree::PostfixRankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
-auto ExactRepeatsNaivePrefixRankedBarTree = ExactSubtreeRepeatsNaive::RegistratorWrapper < tree::PrefixRankedBarTree < unsigned, DefaultRankType >, tree::PrefixRankedBarTree < > > ( ExactSubtreeRepeatsNaive::repeats );
+auto ExactRepeatsNaiveRankedTree = registration::OverloadRegister < ExactSubtreeRepeatsNaive, tree::RankedTree < unsigned, DefaultRankType >, tree::RankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
+auto ExactRepeatsNaivePrefixRankedTree = registration::OverloadRegister < ExactSubtreeRepeatsNaive, tree::PrefixRankedTree < unsigned, DefaultRankType >, tree::PrefixRankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
+auto ExactRepeatsNaivePostfixRankedTree = registration::OverloadRegister < ExactSubtreeRepeatsNaive, tree::PostfixRankedTree < unsigned, DefaultRankType >, tree::PostfixRankedTree < > > ( ExactSubtreeRepeatsNaive::repeats );
+auto ExactRepeatsNaivePrefixRankedBarTree = registration::OverloadRegister < ExactSubtreeRepeatsNaive, tree::PrefixRankedBarTree < unsigned, DefaultRankType >, tree::PrefixRankedBarTree < > > ( ExactSubtreeRepeatsNaive::repeats );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/tree/properties/ReversedBadCharacterShiftTable.cpp b/alib2algo/src/tree/properties/ReversedBadCharacterShiftTable.cpp
index dd9f293170bee3364b401922a28972d22a48121f..c1e4f0d9e3e9369796af7b3d9bc091f6696faa86 100644
--- a/alib2algo/src/tree/properties/ReversedBadCharacterShiftTable.cpp
+++ b/alib2algo/src/tree/properties/ReversedBadCharacterShiftTable.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReversedBadCharacterShiftTable.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -15,10 +16,10 @@ std::map < std::ranked_symbol < >, size_t > ReversedBadCharacterShiftTable::bcs
 	return dispatch ( pattern.getData ( ) );
 }
 
-auto ReversedBadCharacterShiftTablePrefixRankedBarPattern = ReversedBadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarPattern < > > ( ReversedBadCharacterShiftTable::bcs );
-auto ReversedBadCharacterShiftTablePrefixRankedBarNonlinearPattern = ReversedBadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarNonlinearPattern < > > ( ReversedBadCharacterShiftTable::bcs );
-auto ReversedBadCharacterShiftTablePrefixRankedPattern = ReversedBadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedPattern < > > ( ReversedBadCharacterShiftTable::bcs );
-auto ReversedBadCharacterShiftTablePrefixRankedNonlinearPattern = ReversedBadCharacterShiftTable::RegistratorWrapper < std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedNonlinearPattern < > > ( ReversedBadCharacterShiftTable::bcs );
+auto ReversedBadCharacterShiftTablePrefixRankedBarPattern = registration::OverloadRegister < ReversedBadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarPattern < > > ( ReversedBadCharacterShiftTable::bcs );
+auto ReversedBadCharacterShiftTablePrefixRankedBarNonlinearPattern = registration::OverloadRegister < ReversedBadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedBarNonlinearPattern < > > ( ReversedBadCharacterShiftTable::bcs );
+auto ReversedBadCharacterShiftTablePrefixRankedPattern = registration::OverloadRegister < ReversedBadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedPattern < > > ( ReversedBadCharacterShiftTable::bcs );
+auto ReversedBadCharacterShiftTablePrefixRankedNonlinearPattern = registration::OverloadRegister < ReversedBadCharacterShiftTable, std::map < std::ranked_symbol < >, size_t >, tree::PrefixRankedNonlinearPattern < > > ( ReversedBadCharacterShiftTable::bcs );
 
 } /* namespace properties */
 
diff --git a/alib2algo/src/tree/properties/SubtreeJumpTable.cpp b/alib2algo/src/tree/properties/SubtreeJumpTable.cpp
index cd756d6f64501ac712c8bd717981eaf0704b9c3b..2ecbcc7d62066edcec2186c185a9c5d0e72bdf20 100644
--- a/alib2algo/src/tree/properties/SubtreeJumpTable.cpp
+++ b/alib2algo/src/tree/properties/SubtreeJumpTable.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SubtreeJumpTable.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace tree {
 
@@ -15,10 +16,10 @@ std::vector < int > SubtreeJumpTable::compute ( const tree::RankedTreeWrapper &
 	return dispatch ( subject.getData ( ) );
 }
 
-auto SubtreeSizesPrefixRankedBarTree = SubtreeJumpTable::RegistratorWrapper < std::vector < int >, tree::PrefixRankedBarTree < > > ( SubtreeJumpTable::compute );
-auto SubtreeSizesPrefixRankedBarPattern = SubtreeJumpTable::RegistratorWrapper < std::vector < int >, tree::PrefixRankedBarPattern < > > ( SubtreeJumpTable::compute );
-auto SubtreeSizesPrefixRankedTree = SubtreeJumpTable::RegistratorWrapper < std::vector < int >, tree::PrefixRankedTree < > > ( SubtreeJumpTable::compute );
-auto SubtreeSizesPrefixRankedPattern = SubtreeJumpTable::RegistratorWrapper < std::vector < int >, tree::PrefixRankedPattern < > > ( SubtreeJumpTable::compute );
+auto SubtreeSizesPrefixRankedBarTree = registration::OverloadRegister < SubtreeJumpTable, std::vector < int >, tree::PrefixRankedBarTree < > > ( SubtreeJumpTable::compute );
+auto SubtreeSizesPrefixRankedBarPattern = registration::OverloadRegister < SubtreeJumpTable, std::vector < int >, tree::PrefixRankedBarPattern < > > ( SubtreeJumpTable::compute );
+auto SubtreeSizesPrefixRankedTree = registration::OverloadRegister < SubtreeJumpTable, std::vector < int >, tree::PrefixRankedTree < > > ( SubtreeJumpTable::compute );
+auto SubtreeSizesPrefixRankedPattern = registration::OverloadRegister < SubtreeJumpTable, std::vector < int >, tree::PrefixRankedPattern < > > ( SubtreeJumpTable::compute );
 
 } /* namespace properties */
 
diff --git a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
index 686e3de703ec86b0fd3c509c21fef7305e913f07..eefcd92fdbe050a9c1e6c46143428e023419d576 100644
--- a/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/DeterministicLL1Grammar.cpp
@@ -15,6 +15,7 @@
 #include <algorithm>
 
 #include <grammar/properties/RecursiveNonterminal.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -79,7 +80,7 @@ grammar::CFG < > DeterministicLL1Grammar::convert ( const grammar::CFG < > & par
 	}
 }
 
-auto DeterministicLL1GrammarCFG = DeterministicLL1Grammar::RegistratorWrapper < grammar::CFG < >, grammar::CFG < > > ( DeterministicLL1Grammar::convert );
+auto DeterministicLL1GrammarCFG = registration::OverloadRegister < DeterministicLL1Grammar, grammar::CFG < >, grammar::CFG < > > ( DeterministicLL1Grammar::convert );
 
 grammar::Grammar DeterministicLL1Grammar::convert ( const grammar::Grammar & grammar ) {
 	return dispatch ( grammar.getData ( ) );
diff --git a/alib2algo_experimental/src/grammar/parsing/First.cpp b/alib2algo_experimental/src/grammar/parsing/First.cpp
index 9e736b686eb9afc372356439f87cc8e91f937ecc..19cd4f71b9aaf6d222ee03070eccd520a2a7466b 100644
--- a/alib2algo_experimental/src/grammar/parsing/First.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/First.cpp
@@ -17,6 +17,7 @@
 #include <grammar/Regular/RightLG.h>
 #include <grammar/Regular/RightRG.h>
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -104,29 +105,29 @@ std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::firs
 	return first ( grammar.getTerminalAlphabet ( ), grammar.getNonterminalAlphabet ( ), firstNt, rhs );
 }
 
-auto FirstCFG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::CFG < > > ( First::first );
-auto FirstEpsilonFreeCFG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::EpsilonFreeCFG < > > ( First::first );
-auto FirstGNF = FirstBase1::RegistratorWrapper < FirstResult1, grammar::GNF < > > ( First::first );
-auto FirstCNF = FirstBase1::RegistratorWrapper < FirstResult1, grammar::CNF < > > ( First::first );
-auto FirstLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LG < > > ( First::first );
-auto FirstLeftLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LeftLG < > > ( First::first );
-auto FirstLeftRG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::LeftRG < > > ( First::first );
-auto FirstRightLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightLG < > > ( First::first );
-auto FirstRightRG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightRG < > > ( First::first );
+auto FirstCFG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::CFG < > > ( First::first );
+auto FirstEpsilonFreeCFG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::EpsilonFreeCFG < > > ( First::first );
+auto FirstGNF = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::GNF < > > ( First::first );
+auto FirstCNF = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::CNF < > > ( First::first );
+auto FirstLG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::LG < > > ( First::first );
+auto FirstLeftLG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::LeftLG < > > ( First::first );
+auto FirstLeftRG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::LeftRG < > > ( First::first );
+auto FirstRightLG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::RightLG < > > ( First::first );
+auto FirstRightRG = registration::OverloadRegister < FirstBase1, FirstResult1, grammar::RightRG < > > ( First::first );
 
 std::map < std::vector < DefaultSymbolType >, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > First::first ( const grammar::Grammar & grammar ) {
 	return FirstBase1::dispatch ( grammar.getData ( ) );
 }
 
-auto FirstCFG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::CFG < > > ( First::first );
-auto FirstEpsilonFreeCFG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::EpsilonFreeCFG < > > ( First::first );
-auto FirstGNF2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::GNF < > > ( First::first );
-auto FirstCNF2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::CNF < > > ( First::first );
-auto FirstLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LG < > > ( First::first );
-auto FirstLeftLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LeftLG < > > ( First::first );
-auto FirstLeftRG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::LeftRG < > > ( First::first );
-auto FirstRightLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightLG < > > ( First::first );
-auto FirstRightRG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightRG < > > ( First::first );
+auto FirstCFG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::CFG < > > ( First::first );
+auto FirstEpsilonFreeCFG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::EpsilonFreeCFG < > > ( First::first );
+auto FirstGNF2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::GNF < > > ( First::first );
+auto FirstCNF2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::CNF < > > ( First::first );
+auto FirstLG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::LG < > > ( First::first );
+auto FirstLeftLG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::LeftLG < > > ( First::first );
+auto FirstLeftRG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::LeftRG < > > ( First::first );
+auto FirstRightLG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::RightLG < > > ( First::first );
+auto FirstRightRG2 = registration::OverloadRegister < FirstBase2, FirstResult2, grammar::RightRG < > > ( First::first );
 
 std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > First::first ( const grammar::Grammar & grammar, const std::vector < DefaultSymbolType > & rhs ) {
 	return FirstBase2::dispatch ( grammar.getData ( ), rhs );
diff --git a/alib2algo_experimental/src/grammar/parsing/Follow.cpp b/alib2algo_experimental/src/grammar/parsing/Follow.cpp
index a75ecc831e62f2b6497cbf98b374d07bf06ba653..05e63a8b97e3ed3c54a8403ba7c23bbb03fbc656 100644
--- a/alib2algo_experimental/src/grammar/parsing/Follow.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/Follow.cpp
@@ -21,6 +21,7 @@
 #include <grammar/Regular/RightLG.h>
 #include <grammar/Regular/RightRG.h>
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -92,29 +93,29 @@ std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > Follow::fol
 	return follow ( grammar )[nt];
 }
 
-auto FollowCFG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::CFG < > > ( Follow::follow );
-auto FollowEpsilonFreeCFG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::EpsilonFreeCFG < > > ( Follow::follow );
-auto FollowGNF = FollowBase1::RegistratorWrapper < FollowResult1, grammar::GNF < > > ( Follow::follow );
-auto FollowCNF = FollowBase1::RegistratorWrapper < FollowResult1, grammar::CNF < > > ( Follow::follow );
-auto FollowLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LG < > > ( Follow::follow );
-auto FollowLeftLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LeftLG < > > ( Follow::follow );
-auto FollowLeftRG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::LeftRG < > > ( Follow::follow );
-auto FollowRightLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightLG < > > ( Follow::follow );
-auto FollowRightRG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightRG < > > ( Follow::follow );
+auto FollowCFG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::CFG < > > ( Follow::follow );
+auto FollowEpsilonFreeCFG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::EpsilonFreeCFG < > > ( Follow::follow );
+auto FollowGNF = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::GNF < > > ( Follow::follow );
+auto FollowCNF = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::CNF < > > ( Follow::follow );
+auto FollowLG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::LG < > > ( Follow::follow );
+auto FollowLeftLG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::LeftLG < > > ( Follow::follow );
+auto FollowLeftRG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::LeftRG < > > ( Follow::follow );
+auto FollowRightLG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::RightLG < > > ( Follow::follow );
+auto FollowRightRG = registration::OverloadRegister < FollowBase1, FollowResult1, grammar::RightRG < > > ( Follow::follow );
 
 std::map < DefaultSymbolType, std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > > Follow::follow ( const grammar::Grammar & grammar ) {
 	return FollowBase1::dispatch ( grammar.getData ( ) );
 }
 
-auto FollowCFG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::CFG < > > ( Follow::follow );
-auto FollowEpsilonFreeCFG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::EpsilonFreeCFG < > > ( Follow::follow );
-auto FollowGNF2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::GNF < > > ( Follow::follow );
-auto FollowCNF2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::CNF < > > ( Follow::follow );
-auto FollowLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LG < > > ( Follow::follow );
-auto FollowLeftLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LeftLG < > > ( Follow::follow );
-auto FollowLeftRG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::LeftRG < > > ( Follow::follow );
-auto FollowRightLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightLG < > > ( Follow::follow );
-auto FollowRightRG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightRG < > > ( Follow::follow );
+auto FollowCFG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::CFG < > > ( Follow::follow );
+auto FollowEpsilonFreeCFG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::EpsilonFreeCFG < > > ( Follow::follow );
+auto FollowGNF2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::GNF < > > ( Follow::follow );
+auto FollowCNF2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::CNF < > > ( Follow::follow );
+auto FollowLG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::LG < > > ( Follow::follow );
+auto FollowLeftLG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::LeftLG < > > ( Follow::follow );
+auto FollowLeftRG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::LeftRG < > > ( Follow::follow );
+auto FollowRightLG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::RightLG < > > ( Follow::follow );
+auto FollowRightRG2 = registration::OverloadRegister < FollowBase2, FollowResult2, grammar::RightRG < > > ( Follow::follow );
 
 std::set < std::variant < DefaultSymbolType, string::Epsilon < > > > Follow::follow ( const grammar::Grammar & grammar, const DefaultSymbolType & nt ) {
 	return FollowBase2::dispatch ( grammar.getData ( ), nt );
diff --git a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
index 6d3e45f867d9f39b1ceac8dacf8ff0e0bea0870f..2af69eb5bea5110ea6c5fa8cbaf0bd18d0b34fa9 100644
--- a/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
+++ b/alib2algo_experimental/src/grammar/parsing/LL1ParseTable.cpp
@@ -18,6 +18,7 @@
 #include <grammar/Regular/LeftRG.h>
 #include <grammar/Regular/RightLG.h>
 #include <grammar/Regular/RightRG.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -50,15 +51,15 @@ std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >,
 	return res;
 }
 
-auto LL1ParseTableCFG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableEpsilonFreeCFG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableGNF = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableCNF = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableLeftRG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightLG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightRG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableEpsilonFreeCFG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::EpsilonFreeCFG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableGNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::GNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableCNF = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::CNF < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLG  = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftLG  = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableLeftRG  = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightLG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightRG = registration::OverloadRegister < LL1ParseTable, std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > >, grammar::RightRG < > > ( LL1ParseTable::parseTable );
 
 std::map < std::pair < std::variant < DefaultSymbolType, string::Epsilon < > >, DefaultSymbolType >, std::set < std::vector < DefaultSymbolType > > > LL1ParseTable::parseTable ( const grammar::Grammar & grammar ) {
 	return dispatch ( grammar.getData ( ) );
diff --git a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
index 6788e0af26e1f0175bb765c059d24a71f306bc86..495d8c9c1962e7684ccfea7cccd342c84706f07e 100644
--- a/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/maximumflow/FordFulkerson.cpp
@@ -15,6 +15,7 @@
 #include <stdexcept>
 
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 
 // the flow needs to be assigned to pair of nodes, not edge
@@ -239,7 +240,7 @@ Flow FordFulkerson::fordfulkerson( const UndirectedGraph & graph, Node source, N
 	return fordfulkerson_impl_undir( graph, source, sink );
 }
 
-//auto FordFulkersonUndirectedGraph = FordFulkerson::RegistratorWrapper< graph::UndirectedGraph, graph::UndirectedGraph >( FordFulkerson::getInstance(), FordFulkerson::fordfulkerson );
+//auto FordFulkersonUndirectedGraph = registration::OverloadRegister < FordFulkerson,  graph::UndirectedGraph, graph::UndirectedGraph > ( FordFulkerson::fordfulkerson );
 
 }
 
diff --git a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
index 892dd1fe41642462d73b6023cd0a981190467c81..de46f367b49128f9eedbc942eeec1c5988681fbc 100644
--- a/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
+++ b/alib2algo_experimental/src/graph/minimumcut/FordFulkerson.cpp
@@ -17,6 +17,7 @@
 #include <exception/CommonException.h>
 
 #include "../maximumflow/FordFulkerson.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -169,7 +170,7 @@ Cut FordFulkerson::fordfulkerson( const UndirectedGraph & graph, Node source, No
 	return fordfulkerson_impl_undir( graph, source, sink );
 }
 
-//auto BasicAlgorithmUndirectedGraph = FordFulkerson::RegistratorWrapper< graph::UndirectedGraph, graph::UndirectedGraph >( FordFulkerson::getInstance(), FordFulkerson::fordfulkerson );
+//auto BasicAlgorithmUndirectedGraph = registration::OverloadRegister < FordFulkerson, graph::UndirectedGraph, graph::UndirectedGraph > ( FordFulkerson::fordfulkerson );
 
 } // namespace minimumcut
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
index 6bb132e1d100f3a262410c23a4cf18f64f6eed26..c1544ba951c0bf76fcd6e6545d910f04fc3b911f 100644
--- a/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/BellmanFord.cpp
@@ -8,6 +8,7 @@
 #include "BellmanFord.h"
 
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph
 {
@@ -119,14 +120,14 @@ BellmanFord::Result BellmanFord::bellmanford(const DirectedGraph &graph, const N
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordDirectedGraph = BellmanFord::RegistratorWrapper<BellmanFord::Result, graph::DirectedGraph>(BellmanFord::bellmanford);
+auto BellmanFordDirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::DirectedGraph> ( BellmanFord::bellmanford );
 
 BellmanFord::Result BellmanFord::bellmanford(const UndirectedGraph &graph, const Node &start)
 {
 	return bellmanford_impl(graph, start);
 }
 
-auto BellmanFordUndirectedGraph = BellmanFord::RegistratorWrapper<BellmanFord::Result, graph::UndirectedGraph>(BellmanFord::bellmanford);
+auto BellmanFordUndirectedGraph = registration::OverloadRegister < BellmanFord, BellmanFord::Result, graph::UndirectedGraph> ( BellmanFord::bellmanford );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
index bfcef0813ae701d5f24f114f89ed221d50909e7f..fc6a2d1e05ee6dd26d7ad3c8bce6e9ac2b5cc84d 100644
--- a/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/Dijkstra.cpp
@@ -8,6 +8,7 @@
 #include "Dijkstra.h"
 
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph
 {
@@ -135,14 +136,14 @@ Dijkstra::Result Dijkstra::dijkstra(const DirectedGraph &graph, const Node &star
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraDirectedGraph = Dijkstra::RegistratorWrapper<Dijkstra::Result, graph::DirectedGraph>(Dijkstra::dijkstra);
+auto DijkstraDirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::DirectedGraph> ( Dijkstra::dijkstra );
 
 Dijkstra::Result Dijkstra::dijkstra(const UndirectedGraph &graph, const Node &start)
 {
 	return dijkstra_impl(graph, start);
 }
 
-auto DijkstraUndirectedGraph = Dijkstra::RegistratorWrapper<Dijkstra::Result, graph::UndirectedGraph>(Dijkstra::dijkstra);
+auto DijkstraUndirectedGraph = registration::OverloadRegister < Dijkstra, Dijkstra::Result, graph::UndirectedGraph> ( Dijkstra::dijkstra );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
index d471b3efb5da100d71f62e1e592555299f4a2d78..b1a0235aa670646797cf25a0bad3d3f15cd2b656 100644
--- a/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
+++ b/alib2algo_experimental/src/graph/shortestpath/FloydWarshall.cpp
@@ -10,6 +10,7 @@
 #include <exception/CommonException.h>
 
 #include <limits>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph
 {
@@ -74,14 +75,14 @@ FloydWarshall::Result FloydWarshall::floydwarshall(const DirectedGraph &graph)
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallDirectedGraph = FloydWarshall::RegistratorWrapper<FloydWarshall::Result, graph::DirectedGraph>(FloydWarshall::floydwarshall);
+auto FloydWarshallDirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::DirectedGraph> ( FloydWarshall::floydwarshall );
 
 FloydWarshall::Result FloydWarshall::floydwarshall(const UndirectedGraph &graph)
 {
 	return floydwarshall_impl(graph);
 }
 
-auto FloydWarshallUndirectedGraph = FloydWarshall::RegistratorWrapper<FloydWarshall::Result, graph::UndirectedGraph>(FloydWarshall::floydwarshall);
+auto FloydWarshallUndirectedGraph = registration::OverloadRegister < FloydWarshall, FloydWarshall::Result, graph::UndirectedGraph> ( FloydWarshall::floydwarshall );
 
 } // namespace shortestpath
 
diff --git a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
index e0e4e07eabacafbe1a24f2343f78ebe468b3df33..99c053b635615c06db19c3a403965c05b1d74d33 100644
--- a/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
+++ b/alib2algo_experimental/src/graph/sort/TopologicalSort.cpp
@@ -7,6 +7,7 @@
 
 #include "TopologicalSort.h"
 #include "../traverse/Dfs.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -38,7 +39,7 @@ TopologicalSort::Result TopologicalSort::topologicalsort(const DirectedGraph &gr
 	return topsort_impl(graph);
 }
 
-auto TopologicalSortDirectedGraph = TopologicalSort::RegistratorWrapper<TopologicalSort::Result, graph::DirectedGraph>(TopologicalSort::topologicalsort);
+auto TopologicalSortDirectedGraph = registration::OverloadRegister < TopologicalSort, TopologicalSort::Result, graph::DirectedGraph> ( TopologicalSort::topologicalsort );
 
 } // namespace sort
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
index 1172cbfc1786bc4bf50411f0d7896c9e82434c84..0d59a65fb035d0f366dc9e5c4d66cd3c13cfc28b 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Edmonds.cpp
@@ -20,6 +20,7 @@
 #include "../datastructs/Array.h"
 
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -245,7 +246,7 @@ AdjacencyListDirectedGraph Edmonds::edmonds( const DirectedGraph & graph )
 	return edmonds_impl( graph );
 }
 
-auto EdmondsDirectedGraph = Edmonds::RegistratorWrapper< graph::AdjacencyListDirectedGraph, graph::DirectedGraph >( Edmonds::edmonds );
+auto EdmondsDirectedGraph = registration::OverloadRegister < Edmonds,  graph::AdjacencyListDirectedGraph, graph::DirectedGraph > ( Edmonds::edmonds );
 
 } // spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
index 5749136b8eadc7cbb6096608a735ed2c8322a208..b3dfebeb5d565ae3825d0ebff3239d53b1feb3fa 100644
--- a/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/JarnikPrim.cpp
@@ -8,6 +8,7 @@
 #include "JarnikPrim.h"
 
 #include <limits>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -108,7 +109,7 @@ AdjacencyListUndirectedGraph JarnikPrim::jarnikprim(const UndirectedGraph &graph
 	return jarnikprim_impl(graph, start);
 }
 
-auto JarnikPrimUndirectedGraph = JarnikPrim::RegistratorWrapper<graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph>(JarnikPrim::jarnikprim);
+auto JarnikPrimUndirectedGraph = registration::OverloadRegister < JarnikPrim, graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph> ( JarnikPrim::jarnikprim );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
index be551c6ca43f7e1fae9522a8b09dff83ce49f4f4..b37037a9c2836c9cf6e2aac2029db6ce9cf6e60d 100644
--- a/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
+++ b/alib2algo_experimental/src/graph/spanningtree/Kruskal.cpp
@@ -14,6 +14,7 @@
 
 #include "../datastructs/Components.h"
 #include <exception/CommonException.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -84,7 +85,7 @@ AdjacencyListUndirectedGraph Kruskal::kruskal( const UndirectedGraph & graph )
 	return kruskal_impl( graph );
 }
 
-auto KruskalUndirectedGraph = Kruskal::RegistratorWrapper< graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph >( Kruskal::kruskal );
+auto KruskalUndirectedGraph = registration::OverloadRegister < Kruskal,  graph::AdjacencyListUndirectedGraph, graph::UndirectedGraph > ( Kruskal::kruskal );
 
 } // namespace spanningtree
 
diff --git a/alib2algo_experimental/src/graph/traverse/Bfs.cpp b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
index 974e0c70245cbec8eec879c8b9c1b1aace5710bc..b7820afa0bd34eb0dc5f7fb02e964e11814814f1 100644
--- a/alib2algo_experimental/src/graph/traverse/Bfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Bfs.cpp
@@ -9,6 +9,7 @@
 
 #include <queue>
 #include <unordered_map>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -77,25 +78,25 @@ void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::Function func)
 	bfs_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph1 = std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>::RegistratorWrapper<void, graph::DirectedGraph>(Bfs::bfs);
+auto BfsDirectedGraph1 = registration::OverloadRegister < std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const DirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsDirectedGraph2 = std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>::RegistratorWrapper<void, graph::DirectedGraph>(Bfs::bfs);
+auto BfsDirectedGraph2 = registration::OverloadRegister < std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::DirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::Function func) {
 	bfs_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph1 = std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>::RegistratorWrapper<void, graph::UndirectedGraph>(Bfs::bfs);
+auto BfsUndirectedGraph1 = registration::OverloadRegister < std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::Function>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 void Bfs::bfs(const UndirectedGraph &graph, const Node &start, Bfs::FunctionExt func) {
 	bfs2_impl(graph, start, func);
 }
 
-auto BfsUndirectedGraph2 = std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>::RegistratorWrapper<void, graph::UndirectedGraph>(Bfs::bfs);
+auto BfsUndirectedGraph2 = registration::OverloadRegister < std::SingleDispatch<Bfs, void, const graph::GraphBase &, const Node&, Bfs::FunctionExt>, void, graph::UndirectedGraph> ( Bfs::bfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/graph/traverse/Dfs.cpp b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
index 50dcfea7a738abb9ca57f9078c72e318a4a2d02f..554c070728b1682e4ee01ddb4c74b0286f1b803d 100644
--- a/alib2algo_experimental/src/graph/traverse/Dfs.cpp
+++ b/alib2algo_experimental/src/graph/traverse/Dfs.cpp
@@ -9,6 +9,7 @@
 
 #include <stack>
 #include <unordered_map>
+#include <registration/AlgoRegistration.hpp>
 
 namespace graph {
 
@@ -66,7 +67,7 @@ void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::Function func)
 	dfs_impl(graph, start, func);
 }
 
-auto DfsDirectedGraph1 = std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>::RegistratorWrapper<void, graph::DirectedGraph>(Dfs::dfs);
+auto DfsDirectedGraph1 = registration::OverloadRegister < std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -74,13 +75,13 @@ void Dfs::dfs(const DirectedGraph &graph, const Node &start, Dfs::FunctionExt fu
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsDirectedGraph2 = std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>::RegistratorWrapper<void, graph::DirectedGraph>(Dfs::dfs);
+auto DfsDirectedGraph2 = registration::OverloadRegister < std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::DirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::Function func) {
 	dfs_impl(graph, start, func);
 }
 
-auto DfsUndirectedGraph1 = std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>::RegistratorWrapper<void, graph::UndirectedGraph>(Dfs::dfs);
+auto DfsUndirectedGraph1 = registration::OverloadRegister < std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::Function>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt func) {
 	int time = 0;
@@ -88,7 +89,7 @@ void Dfs::dfs(const UndirectedGraph &graph, const Node &start, Dfs::FunctionExt
 	dfs2_impl(graph, start, start, visited, time, func);
 }
 
-auto DfsUndirectedGraph2 = std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>::RegistratorWrapper<void, graph::UndirectedGraph>(Dfs::dfs);
+auto DfsUndirectedGraph2 = registration::OverloadRegister < std::SingleDispatch<Dfs, void, const graph::GraphBase &, const Node&, Dfs::FunctionExt>, void, graph::UndirectedGraph> ( Dfs::dfs );
 
 } // namespace traverse
 
diff --git a/alib2algo_experimental/src/stringology/indexing/ExperimentalSuffixTrie.cpp b/alib2algo_experimental/src/stringology/indexing/ExperimentalSuffixTrie.cpp
index 6f796848d549966e0465ba64ab869b74b3ac36bd..e7c38aa4048eca26ee1cb21c3697f1a87de62947 100644
--- a/alib2algo_experimental/src/stringology/indexing/ExperimentalSuffixTrie.cpp
+++ b/alib2algo_experimental/src/stringology/indexing/ExperimentalSuffixTrie.cpp
@@ -8,6 +8,7 @@
 #include "ExperimentalSuffixTrie.h"
 
 #include <string/LinearStringTerminatingSymbol.h>
+#include <registration/AlgoRegistration.hpp>
 
 namespace stringology {
 
@@ -35,7 +36,7 @@ indexes::SuffixTrieTerminatingSymbol ExperimentalSuffixTrie::construct ( const s
 	return res;
 }
 
-auto SuffixTrieTerminatingSymbolLinearStringTerminatingSymbol = ExperimentalSuffixTrie::RegistratorWrapper < indexes::SuffixTrieTerminatingSymbol, string::LinearStringTerminatingSymbol > ( ExperimentalSuffixTrie::construct );
+auto SuffixTrieTerminatingSymbolLinearStringTerminatingSymbol = registration::OverloadRegister < ExperimentalSuffixTrie, indexes::SuffixTrieTerminatingSymbol, string::LinearStringTerminatingSymbol > ( ExperimentalSuffixTrie::construct );
 
 } /* namespace indexing */
 
diff --git a/alib2common/src/core/multipleDispatch.hpp b/alib2common/src/core/multipleDispatch.hpp
index c0c3127e3caf4fe9c6c4e24f59828a92aa4be3ca..a4005b2653f631a4d39932acbe7e4d03909e3c21 100644
--- a/alib2common/src/core/multipleDispatch.hpp
+++ b/alib2common/src/core/multipleDispatch.hpp
@@ -14,10 +14,10 @@
 #include <iostream>
 #include <type_traits>
 #include <sstream>
+#include <tuple>
 
-#include "castApi.hpp"
-#include "../exception/CommonException.h"
-#include <introspection/Algorithms.hpp>
+#include <core/castApi.hpp>
+#include <exception/CommonException.h>
 
 namespace std {
 
@@ -27,12 +27,37 @@ class MultipleDispatch;
 template < class Algorithm, class ReturnType, class ... FrontStaticParamTypes, class ... DispatchedParameterTypes, class ... BackStaticParamTypes >
 class MultipleDispatch < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > {
 public:
+	template < class RealReturnType, class ... RealParameterTypeBases >
+	using overload = std::function < RealReturnType ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) >;
+
+	template < class RealReturnType, class ... RealParameterTypeBases >
+	using rawOverload = RealReturnType ( * ) ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... );
+
+	typedef std::tuple < FrontStaticParamTypes ... > frontParams;
+	typedef std::tuple < DispatchedParameterTypes ... > dispatchedParams;
+	typedef std::tuple < BackStaticParamTypes ... > backParams;
+	typedef ReturnType returnType;
+
+private:
 	class RegistratorWrapperBase {
 	public:
 		virtual ReturnType eval ( FrontStaticParamTypes ..., DispatchedParameterTypes && ..., BackStaticParamTypes ... ) = 0;
 	};
 
-private:
+	template < class RealReturnType, class ... RealParameterTypeBases >
+	class RegistratorWrapper : public RegistratorWrapperBase {
+		overload < RealReturnType, RealParameterTypeBases ... > m_callback;
+
+	public:
+		ReturnType eval ( FrontStaticParamTypes ... front, DispatchedParameterTypes && ... dispatched, BackStaticParamTypes ... back ) {
+			return ReturnType ( m_callback ( front ..., std::forward < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( static_cast < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && > ( dispatched ) ) ..., back ... ) );
+		}
+
+		RegistratorWrapper ( overload < RealReturnType, RealParameterTypeBases ... > callback ) : m_callback ( callback ) {
+		}
+
+	};
+
 	std::map < typename std::TupleBuilder < std::type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * > registeredFunctions;
 
 	static MultipleDispatch < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > & getInstance ( ) {
@@ -43,34 +68,26 @@ private:
 
 public:
 	template < class RealReturnType, class ... RealParameterTypeBases >
-	class RegistratorWrapper : public RegistratorWrapperBase {
-		std::function < RealReturnType ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) > m_callback;
-
-	public:
-		ReturnType eval ( FrontStaticParamTypes ... front, DispatchedParameterTypes && ... dispatched, BackStaticParamTypes ... back ) {
-			return ReturnType ( m_callback ( front ..., std::forward < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( static_cast < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && > ( dispatched ) ) ..., back ... ) );
-		}
+//	static void registerOverload ( overload < RealReturnType, RealParameterTypeBases ... > callback ) { causes clang 4.0.0 to crash...
+//	static void registerOverload ( rawOverload < RealReturnType, RealParameterTypeBases ... > callback ) { causes clang 4.0.0 to crash...
+	static void registerOverload ( RealReturnType ( * callback ) ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) ) {
+		auto key = std::make_tuple ( std::type_index ( typeid ( typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type ) ) ... );
+		RegistratorWrapper < RealReturnType, RealParameterTypeBases ... > * value = new RegistratorWrapper < RealReturnType, RealParameterTypeBases ... > ( callback );
 
-		RegistratorWrapper ( RealReturnType ( * callback ) ( FrontStaticParamTypes ..., typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type && ..., BackStaticParamTypes ... ) ) : m_callback ( callback ) {
-			bool res = getInstance ( ).registeredFunctions.insert ( std::make_pair ( std::make_tuple ( std::type_index ( typeid ( typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type ) ) ... ), this ) ).second;
-			if ( ! res ) {
-				std::stringstream ss;
-				( void ) initializer_list < int > { ( ss << std::type_name < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( ), 0 ) ... };
+		bool res = getInstance ( ).registeredFunctions.insert ( std::make_pair ( std::move ( key ), value ) ).second;
 
-				std::string classType = std::type_name < Algorithm > ( );
+		if ( ! res ) {
+			std::stringstream ss;
+			( void ) initializer_list < int > { ( ss << std::type_name < typename std::match_cv_ref < DispatchedParameterTypes, RealParameterTypeBases >::type > ( ), 0 ) ... };
 
-				throw::exception::CommonException ( "Callback for " + ss.str ( ) + " already registered on " + classType + "." );
-			}
+			std::string classType = std::type_name < Algorithm > ( );
 
-			introspection::Algorithms::registerDispatchInAlgorithm < std::tuple < RealParameterTypeBases ... >, Algorithm, RealReturnType > ( );
-			introspection::Algorithms::registerAlgorithmInterface < Algorithm, ReturnType, std::tuple < FrontStaticParamTypes ... >, std::tuple < DispatchedParameterTypes ... >, std::tuple < BackStaticParamTypes ... > > ( );
-			introspection::Algorithms::registerAlgorithm < Algorithm > ( );
+			throw::exception::CommonException ( "Callback for " + ss.str ( ) + " already registered on " + classType + "." );
 		}
-
-	};
+	}
 
 	static ReturnType dispatch ( FrontStaticParamTypes ... front, DispatchedParameterTypes && ... dispatched, BackStaticParamTypes ... back ) {
-		typename std::map < typename std::TupleBuilder < std::type_index, sizeof ... ( DispatchedParameterTypes ) >::type, RegistratorWrapperBase * >::iterator callback = getInstance ( ).registeredFunctions.find ( std::make_tuple ( std::type_index ( typeid ( dispatched ) ) ... ) );
+		auto callback = getInstance ( ).registeredFunctions.find ( std::make_tuple ( std::type_index ( typeid ( dispatched ) ) ... ) );
 
 		if ( callback == getInstance ( ).registeredFunctions.end ( ) ) {
 			std::stringstream ss;
@@ -105,22 +122,24 @@ using DoubleDispatchFirstStaticParam = MultipleDispatch < Algorithm, ReturnType,
 template < class Algorithm, class ReturnType, class ParametersType >
 class PromotingDoubleDispatch {
 public:
+	template < class RealReturnType, class RealParametersTypeBase >
+	using overload = std::function < RealReturnType ( typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type &&, typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type && ) >;
+
+	template < class RealReturnType, class RealParametersTypeBase >
+	using rawOverload = RealReturnType ( * ) ( typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type &&, typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type && );
+
+	typedef std::tuple < > frontParams;
+	typedef std::tuple < ParametersType, ParametersType > dispatchedParams;
+	typedef std::tuple < > backParams;
+	typedef ReturnType returnType;
+
+private:
 	class RegistratorWrapperBase {
 	public:
 		virtual ReturnType eval ( bool firstAttempt, ParametersType &&, ParametersType && ) = 0;
 		virtual bool available ( bool firstAttempt, std::type_index first, std::type_index second ) = 0;
 	};
 
-private:
-	std::map < std::type_index, RegistratorWrapperBase * > registeredFunctions;
-
-	static PromotingDoubleDispatch < Algorithm, ReturnType, ParametersType > & getInstance ( ) {
-		static PromotingDoubleDispatch < Algorithm, ReturnType, ParametersType > res;
-
-		return res;
-	}
-
-public:
 	template < class RealReturnType, class RealParametersTypeBase >
 	class RegistratorWrapper : public RegistratorWrapperBase {
 		typedef typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type RealParametersType;
@@ -151,21 +170,32 @@ public:
 		}
 
 		RegistratorWrapper ( RealReturnType ( * callback ) ( RealParametersType &&, RealParametersType && ) ) : m_callback ( callback ) {
-			bool res = getInstance ( ).registeredFunctions.insert ( std::make_pair ( std::type_index ( typeid ( RealParametersType ) ), this ) ).second;
-			if ( ! res ) {
-				std::string paramsType = std::type_name < RealParametersType > ( );
+		}
 
-				std::string classType = std::type_name < Algorithm > ( );
+	};
 
-				throw::exception::CommonException ( "Callback for " + paramsType + " already registered on " + classType + "." );
-			}
+	std::map < std::type_index, RegistratorWrapperBase * > registeredFunctions;
 
-			introspection::Algorithms::registerDispatchInAlgorithm < std::tuple < RealParametersTypeBase >, Algorithm, RealReturnType > ( );
-			introspection::Algorithms::registerAlgorithmInterface < Algorithm, ReturnType, std::tuple < >, std::tuple < ParametersType >, std::tuple < > > ( );
-			introspection::Algorithms::registerAlgorithm < Algorithm > ( );
-		}
+	static PromotingDoubleDispatch < Algorithm, ReturnType, ParametersType > & getInstance ( ) {
+		static PromotingDoubleDispatch < Algorithm, ReturnType, ParametersType > res;
 
-	};
+		return res;
+	}
+
+public:
+	template < class RealReturnType, class RealParametersTypeBase >
+	static void registerOverload ( RealReturnType ( * callback ) ( typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type &&, typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type && ) ) {
+		RegistratorWrapper < RealReturnType, RealParametersTypeBase > * value = new RegistratorWrapper < RealReturnType, RealParametersTypeBase > ( callback );
+
+		bool res = getInstance ( ).registeredFunctions.insert ( std::make_pair ( std::type_index ( typeid ( typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type ) ), value ) ).second;
+		if ( ! res ) {
+			std::string paramsType = std::type_name < typename std::match_cv_ref < ParametersType, RealParametersTypeBase >::type > ( );
+
+			std::string classType = std::type_name < Algorithm > ( );
+
+			throw::exception::CommonException ( "Callback for " + paramsType + " already registered on " + classType + "." );
+		}
+	}
 
 	static ReturnType dispatch ( ParametersType && first, ParametersType && second ) {
 		typename std::map < std::type_index, RegistratorWrapperBase * >::iterator callback = getInstance ( ).registeredFunctions.find ( std::type_index ( typeid ( first ) ) );
diff --git a/alib2common/src/introspection/Algorithms.hpp b/alib2common/src/introspection/Algorithms.hpp
index 00c87da115cbac22a58bfd44585f532bf6692aff..f50472474109281b46e0a9b3e51430d999dc18cd 100644
--- a/alib2common/src/introspection/Algorithms.hpp
+++ b/alib2common/src/introspection/Algorithms.hpp
@@ -59,7 +59,7 @@ public:
 		return algorithms ( );
 	}
 
-	template < class RealParameterTypes, class Algorithm, class RealReturnType >
+	template < class Algorithm, class RealReturnType, class RealParameterTypes >
 	static void registerDispatchInAlgorithm ( ) {
 		std::vector < std::string > realParameterTypeNames = TypesToString < RealParameterTypes >::getTypes ( );
 		std::string algorithm = std::type_name < Algorithm > ( );
diff --git a/alib2common/src/registration/AlgoRegistration.hpp b/alib2common/src/registration/AlgoRegistration.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..096394ce448548c78beef01561b1427755669942
--- /dev/null
+++ b/alib2common/src/registration/AlgoRegistration.hpp
@@ -0,0 +1,23 @@
+#ifndef _ALGO_REGISTRATION_HPP_
+#define _ALGO_REGISTRATION_HPP_
+
+#include <introspection/Algorithms.hpp>
+#include <core/multipleDispatch.hpp>
+
+namespace registration {
+
+template < class Algorithm, class RealReturnType, class ... RealParameterTypeBases >
+class OverloadRegister {
+public:
+	OverloadRegister ( typename Algorithm::template rawOverload < RealReturnType, RealParameterTypeBases ... > callback ) {
+		Algorithm::template registerOverload < RealReturnType, RealParameterTypeBases ... > ( callback );
+
+		introspection::Algorithms::registerDispatchInAlgorithm < Algorithm, RealReturnType, std::tuple < RealParameterTypeBases ... > > ( );
+		introspection::Algorithms::registerAlgorithmInterface < Algorithm, typename Algorithm::returnType, typename Algorithm::frontParams, typename Algorithm::dispatchedParams, typename Algorithm::backParams > ( );
+		introspection::Algorithms::registerAlgorithm < Algorithm > ( );
+	}
+};
+
+} /* namespace registration */
+
+#endif // _ALGO_REGISTRATION_HPP_
diff --git a/alib2common/test-src/core/DispatchTest.cpp b/alib2common/test-src/core/DispatchTest.cpp
index 1b12172eb1d1b2dcb6d5d1a242225df070409025..8a622727b99f49ce0a9dc3fec3be4f74fad21d68 100644
--- a/alib2common/test-src/core/DispatchTest.cpp
+++ b/alib2common/test-src/core/DispatchTest.cpp
@@ -1,5 +1,5 @@
 #include "DispatchTest.h"
-#include "core/multipleDispatch.hpp"
+#include <registration/AlgoRegistration.hpp>
 #include "base/CommonBase.hpp"
 #include <set>
 #include <string>
@@ -222,9 +222,9 @@ int TmpVisitorExtensionTmp1 ( const Tmp1 & first ) {
 	return 1;
 }
 
-auto TmpVisitorTmp1 = TmpVisitor::RegistratorWrapper < int, Tmp1 > ( TmpVisitorExtensionTmp1 );
-auto TmpVisitorTmp2 = TmpVisitor::RegistratorWrapper < int, Tmp2 > ( TmpVisitor::eval );
-auto TmpVisitorTmp3 = TmpVisitor::RegistratorWrapper < int, Tmp3 > ( TmpVisitor::eval );
+auto TmpVisitorTmp1 = registration::OverloadRegister < TmpVisitor, int, Tmp1 > ( TmpVisitorExtensionTmp1 );
+auto TmpVisitorTmp2 = registration::OverloadRegister < TmpVisitor, int, Tmp2 > ( TmpVisitor::eval );
+auto TmpVisitorTmp3 = registration::OverloadRegister < TmpVisitor, int, Tmp3 > ( TmpVisitor::eval );
 
 } /* namespace dispatch */
 
@@ -286,9 +286,9 @@ void TmpVisitor2ExtensionTmp1 ( int & res, const Tmp1 & first ) {
 	res = 1;
 }
 
-auto TmpVisitor2Tmp1 = TmpVisitor2::RegistratorWrapper < void, Tmp1 > ( TmpVisitor2ExtensionTmp1 );
-auto TmpVisitor2Tmp2 = TmpVisitor2::RegistratorWrapper < void, Tmp2 > ( TmpVisitor2::eval );
-auto TmpVisitor2Tmp3 = TmpVisitor2::RegistratorWrapper < void, Tmp3 > ( TmpVisitor2::eval );
+auto TmpVisitor2Tmp1 = registration::OverloadRegister < TmpVisitor2, void, Tmp1 > ( TmpVisitor2ExtensionTmp1 );
+auto TmpVisitor2Tmp2 = registration::OverloadRegister < TmpVisitor2, void, Tmp2 > ( TmpVisitor2::eval );
+auto TmpVisitor2Tmp3 = registration::OverloadRegister < TmpVisitor2, void, Tmp3 > ( TmpVisitor2::eval );
 
 } /* namespace dispatch */
 
@@ -351,9 +351,9 @@ int TmpVisitor3ExtensionTmp1 ( Tmp1 && first ) {
 	return 1;
 }
 
-auto TmpVisitor3Tmp1 = TmpVisitor3::RegistratorWrapper < int, Tmp1 > ( TmpVisitor3ExtensionTmp1 );
-auto TmpVisitor3Tmp2 = TmpVisitor3::RegistratorWrapper < int, Tmp2 > ( TmpVisitor3::eval );
-auto TmpVisitor3Tmp3 = TmpVisitor3::RegistratorWrapper < int, Tmp3 > ( TmpVisitor3::eval );
+auto TmpVisitor3Tmp1 = registration::OverloadRegister < TmpVisitor3, int, Tmp1 > ( TmpVisitor3ExtensionTmp1 );
+auto TmpVisitor3Tmp2 = registration::OverloadRegister < TmpVisitor3, int, Tmp2 > ( TmpVisitor3::eval );
+auto TmpVisitor3Tmp3 = registration::OverloadRegister < TmpVisitor3, int, Tmp3 > ( TmpVisitor3::eval );
 
 } /* namespace dispatch */
 
diff --git a/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.cpp b/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.cpp
index 0966da94359bf56a23882e28c90d49be7ba649ff..47020b1ccd97739a588828fa656cf14e080e5a45 100644
--- a/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.cpp
+++ b/alib2elgo/src/automaton/properties/efficient/AllEpsilonClosure.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "AllEpsilonClosure.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -13,12 +14,12 @@ namespace properties {
 
 namespace efficient {
 
-auto AllEpsilonClosureEpsilonNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::EpsilonNFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureMultiInitialStateNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::MultiInitialStateNFA < >>(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::NFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureDFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::DFA<>>(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureExtendedNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::ExtendedNFA < > >(AllEpsilonClosure::allEpsilonClosure);
-auto AllEpsilonClosureCompactNFA = AllEpsilonClosure::RegistratorWrapper<std::map<DefaultStateType, std::set<DefaultStateType>>, automaton::CompactNFA < > >(AllEpsilonClosure::allEpsilonClosure);
+auto AllEpsilonClosureEpsilonNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::EpsilonNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureMultiInitialStateNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set < DefaultStateType > >, automaton::MultiInitialStateNFA < >> ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set<DefaultStateType > >, automaton::NFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureDFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set<DefaultStateType > >, automaton::DFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureExtendedNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set<DefaultStateType > >, automaton::ExtendedNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
+auto AllEpsilonClosureCompactNFA = registration::OverloadRegister < AllEpsilonClosure, std::map < DefaultStateType, std::set<DefaultStateType > >, automaton::CompactNFA < > > ( AllEpsilonClosure::allEpsilonClosure );
 
 std::map<DefaultStateType, std::set<DefaultStateType>> AllEpsilonClosure::allEpsilonClosure(const Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2elgo/src/automaton/properties/efficient/ReachableStates.cpp b/alib2elgo/src/automaton/properties/efficient/ReachableStates.cpp
index b634efafda090605dbc29ed78163419a0cf32638..4ec4d300a08c48810c79bcdd132b8bffbfd66fbd 100644
--- a/alib2elgo/src/automaton/properties/efficient/ReachableStates.cpp
+++ b/alib2elgo/src/automaton/properties/efficient/ReachableStates.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "ReachableStates.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -17,12 +18,12 @@ std::set<DefaultStateType> ReachableStates::reachableStates(const Automaton& aut
 	return dispatch(automaton.getData());
 }
 
-auto ReachableStatesEpsilonNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::EpsilonNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::NFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesCompactNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::CompactNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesExtendedNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::ExtendedNFA < > >(ReachableStates::reachableStates);
-auto ReachableStatesMultiInitialStateNFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::MultiInitialStateNFA < >>(ReachableStates::reachableStates);
-auto ReachableStatesDFA = ReachableStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::DFA < > >(ReachableStates::reachableStates);
+auto ReachableStatesEpsilonNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::EpsilonNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::NFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesCompactNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::CompactNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesExtendedNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::ExtendedNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesMultiInitialStateNFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::MultiInitialStateNFA < > > ( ReachableStates::reachableStates );
+auto ReachableStatesDFA = registration::OverloadRegister < ReachableStates, std::set < DefaultStateType >, automaton::DFA < > > ( ReachableStates::reachableStates );
 
 } /* namespace efficient */
 
diff --git a/alib2elgo/src/automaton/properties/efficient/UsefullStates.cpp b/alib2elgo/src/automaton/properties/efficient/UsefullStates.cpp
index 5c5db127c91e6f3ad5b98d5ae5224531a99cb83b..6bb9a556ac940c9f599467331d53ee396e69965a 100644
--- a/alib2elgo/src/automaton/properties/efficient/UsefullStates.cpp
+++ b/alib2elgo/src/automaton/properties/efficient/UsefullStates.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "UsefullStates.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -17,12 +18,12 @@ std::set<DefaultStateType> UsefullStates::usefullStates(const Automaton& automat
 	return dispatch(automaton.getData());
 }
 
-auto UsefullStatesEpsilonNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::EpsilonNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::NFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesCompactNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::CompactNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesExtendedNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::ExtendedNFA < > >(UsefullStates::usefullStates);
-auto UsefullStatesMultiInitialStateNFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::MultiInitialStateNFA < >>(UsefullStates::usefullStates);
-auto UsefullStatesDFA = UsefullStates::RegistratorWrapper<std::set<DefaultStateType>, automaton::DFA < > >(UsefullStates::usefullStates);
+auto UsefullStatesEpsilonNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::EpsilonNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::NFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesCompactNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::CompactNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesExtendedNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::ExtendedNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesMultiInitialStateNFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::MultiInitialStateNFA < > > ( UsefullStates::usefullStates );
+auto UsefullStatesDFA = registration::OverloadRegister < UsefullStates, std::set < DefaultStateType >, automaton::DFA < > > ( UsefullStates::usefullStates );
 
 } /* namespace efficient */
 
diff --git a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.cpp b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.cpp
index cd8be26793a75b94d403af076dbaddbd5ce60fa6..9122e842282c13768d390def9710958d08fd5958 100644
--- a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.cpp
+++ b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverIncoming.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "EpsilonRemoverIncoming.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -13,10 +14,10 @@ namespace simplify {
 
 namespace efficient {
 
-auto EpsilonRemoverIncomingDFA = EpsilonRemoverIncoming::RegistratorWrapper < automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverIncoming::remove );
-auto EpsilonRemoverIncomingMultiInitialStateNFA = EpsilonRemoverIncoming::RegistratorWrapper < automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( EpsilonRemoverIncoming::remove );
-auto EpsilonRemoverIncomingNFA = EpsilonRemoverIncoming::RegistratorWrapper < automaton::NFA < > , automaton::NFA < > > ( EpsilonRemoverIncoming::remove );
-auto EpsilonRemoverIncomingEpsilonNFA = EpsilonRemoverIncoming::RegistratorWrapper < automaton::NFA < > , automaton::EpsilonNFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingDFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingMultiInitialStateNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::NFA < > , automaton::NFA < > > ( EpsilonRemoverIncoming::remove );
+auto EpsilonRemoverIncomingEpsilonNFA = registration::OverloadRegister < EpsilonRemoverIncoming, automaton::NFA < > , automaton::EpsilonNFA < > > ( EpsilonRemoverIncoming::remove );
 
 automaton::Automaton EpsilonRemoverIncoming::remove ( const automaton::Automaton& automaton ) {
 	return dispatch ( automaton.getData ( ) );
diff --git a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.cpp b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.cpp
index 92186055a2036f297c1a98703483de42e4db5e53..4d9c9d9081697dd29c8f4c3e0066023b5ed4916a 100644
--- a/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.cpp
+++ b/alib2elgo/src/automaton/simplify/efficient/EpsilonRemoverOutgoing.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "EpsilonRemoverOutgoing.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -13,10 +14,10 @@ namespace simplify {
 
 namespace efficient {
 
-auto EpsilonRemoverOutgoingDFA = EpsilonRemoverOutgoing::RegistratorWrapper < automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverOutgoing::remove );
-auto EpsilonRemoverOutgoingMultiInitialStateNFA = EpsilonRemoverOutgoing::RegistratorWrapper < automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( EpsilonRemoverOutgoing::remove );
-auto EpsilonRemoverOutgoingNFA = EpsilonRemoverOutgoing::RegistratorWrapper < automaton::NFA < >, automaton::NFA < > > ( EpsilonRemoverOutgoing::remove );
-auto EpsilonRemoverOutgoingEpsilonNFA = EpsilonRemoverOutgoing::RegistratorWrapper < automaton::MultiInitialStateNFA < >, automaton::EpsilonNFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingDFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::DFA < >, automaton::DFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingMultiInitialStateNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::NFA < >, automaton::NFA < > > ( EpsilonRemoverOutgoing::remove );
+auto EpsilonRemoverOutgoingEpsilonNFA = registration::OverloadRegister < EpsilonRemoverOutgoing, automaton::MultiInitialStateNFA < >, automaton::EpsilonNFA < > > ( EpsilonRemoverOutgoing::remove );
 
 automaton::Automaton EpsilonRemoverOutgoing::remove ( const automaton::Automaton& automaton ) {
 	return dispatch ( automaton.getData ( ) );
diff --git a/alib2elgo/src/automaton/simplify/efficient/Trim.cpp b/alib2elgo/src/automaton/simplify/efficient/Trim.cpp
index 8ea90a1caf034b1707776c98dc0b6da49b5683b7..6e1b96135d325649819cb67876138e228d1e3fc9 100644
--- a/alib2elgo/src/automaton/simplify/efficient/Trim.cpp
+++ b/alib2elgo/src/automaton/simplify/efficient/Trim.cpp
@@ -14,6 +14,7 @@
 #include <automaton/FSM/DFA.h>
 
 #include "automaton/Automaton.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -21,12 +22,12 @@ namespace simplify {
 
 namespace efficient {
 
-auto TrimDFA = Trim::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(Trim::trim);
-auto TrimNFA = Trim::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(Trim::trim);
-auto TrimMultiInitialStateNFA = Trim::RegistratorWrapper<automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < >>(Trim::trim);
-auto TrimEpsilonNFA = Trim::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(Trim::trim);
-auto TrimCompactNFA = Trim::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(Trim::trim);
-auto TrimExtendedNFA = Trim::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(Trim::trim);
+auto TrimDFA = registration::OverloadRegister < Trim, automaton::DFA < >, automaton::DFA < > > ( Trim::trim );
+auto TrimNFA = registration::OverloadRegister < Trim, automaton::NFA < > , automaton::NFA < > > ( Trim::trim );
+auto TrimMultiInitialStateNFA = registration::OverloadRegister < Trim, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( Trim::trim );
+auto TrimEpsilonNFA = registration::OverloadRegister < Trim, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( Trim::trim );
+auto TrimCompactNFA = registration::OverloadRegister < Trim, automaton::CompactNFA < >, automaton::CompactNFA < > > ( Trim::trim );
+auto TrimExtendedNFA = registration::OverloadRegister < Trim, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( Trim::trim );
 
 automaton::Automaton Trim::trim(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2elgo/src/automaton/simplify/efficient/UnreachableStatesRemover.cpp b/alib2elgo/src/automaton/simplify/efficient/UnreachableStatesRemover.cpp
index fbef81238a8286c2c0c33d0f8fddbd4307eef81a..1bd3fdce8ce5e1c3a0e7ec851a0ed49915667033 100644
--- a/alib2elgo/src/automaton/simplify/efficient/UnreachableStatesRemover.cpp
+++ b/alib2elgo/src/automaton/simplify/efficient/UnreachableStatesRemover.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "UnreachableStatesRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -13,12 +14,12 @@ namespace simplify {
 
 namespace efficient {
 
-auto UnreachableStatesRemoverEpsilonNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverCompactNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverExtendedNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverDFA = UnreachableStatesRemover::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(UnreachableStatesRemover::remove);
-auto UnreachableStatesRemoverMultiInitialStateNFA = UnreachableStatesRemover::RegistratorWrapper<automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < >>(UnreachableStatesRemover::remove);
+auto UnreachableStatesRemoverEpsilonNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::NFA < > , automaton::NFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverCompactNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::CompactNFA < >, automaton::CompactNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverExtendedNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverDFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::DFA < >, automaton::DFA < > > ( UnreachableStatesRemover::remove );
+auto UnreachableStatesRemoverMultiInitialStateNFA = registration::OverloadRegister < UnreachableStatesRemover, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( UnreachableStatesRemover::remove );
 
 automaton::Automaton UnreachableStatesRemover::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2elgo/src/automaton/simplify/efficient/UselessStatesRemover.cpp b/alib2elgo/src/automaton/simplify/efficient/UselessStatesRemover.cpp
index 34dbc772afa759ab7fc7d2b1bd24827aff9a2a52..628f64a9a6ce83bf654b14c54e760080a629013e 100644
--- a/alib2elgo/src/automaton/simplify/efficient/UselessStatesRemover.cpp
+++ b/alib2elgo/src/automaton/simplify/efficient/UselessStatesRemover.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "UselessStatesRemover.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -13,12 +14,12 @@ namespace simplify {
 
 namespace efficient {
 
-auto UselessStatesRemoverEpsilonNFA = UselessStatesRemover::RegistratorWrapper<automaton::EpsilonNFA < >, automaton::EpsilonNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverNFA = UselessStatesRemover::RegistratorWrapper<automaton::NFA < > , automaton::NFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverCompactNFA = UselessStatesRemover::RegistratorWrapper<automaton::CompactNFA < >, automaton::CompactNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverExtendedNFA = UselessStatesRemover::RegistratorWrapper<automaton::ExtendedNFA < >, automaton::ExtendedNFA < > >(UselessStatesRemover::remove);
-auto UselessStatesRemoverDFA = UselessStatesRemover::RegistratorWrapper<automaton::DFA<>, automaton::DFA<>>(UselessStatesRemover::remove);
-auto UselessStatesRemoverMultiInitialStateNFA = UselessStatesRemover::RegistratorWrapper<automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < >>(UselessStatesRemover::remove);
+auto UselessStatesRemoverEpsilonNFA = registration::OverloadRegister < UselessStatesRemover, automaton::EpsilonNFA < >, automaton::EpsilonNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverNFA = registration::OverloadRegister < UselessStatesRemover, automaton::NFA < > , automaton::NFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverCompactNFA = registration::OverloadRegister < UselessStatesRemover, automaton::CompactNFA < >, automaton::CompactNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverExtendedNFA = registration::OverloadRegister < UselessStatesRemover, automaton::ExtendedNFA < >, automaton::ExtendedNFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverDFA = registration::OverloadRegister < UselessStatesRemover, automaton::DFA < >, automaton::DFA < > > ( UselessStatesRemover::remove );
+auto UselessStatesRemoverMultiInitialStateNFA = registration::OverloadRegister < UselessStatesRemover, automaton::MultiInitialStateNFA < >, automaton::MultiInitialStateNFA < > > ( UselessStatesRemover::remove );
 
 automaton::Automaton UselessStatesRemover::remove(const automaton::Automaton& automaton) {
 	return dispatch(automaton.getData());
diff --git a/alib2raw/src/string/StringToRawComposer.cpp b/alib2raw/src/string/StringToRawComposer.cpp
index adc50e13200421f7a766bab74768a3e20812569b..14b1b3c8eea42cd3563250c1853d4f639877be94 100644
--- a/alib2raw/src/string/StringToRawComposer.cpp
+++ b/alib2raw/src/string/StringToRawComposer.cpp
@@ -8,6 +8,8 @@
 #include <string/StringClasses.h>
 #include "StringToRawComposer.h"
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace string {
 
 void StringToRawComposer::compose(std::ostream& out, const String& string) {
@@ -21,7 +23,7 @@ void StringToRawComposer::compose(std::ostream& out, const LinearString < Symbol
 	}
 }
 
-auto StringToRawComposerLinearString = StringToRawComposer::RegistratorWrapper<void, LinearString < > >(StringToRawComposer::compose);
+auto StringToRawComposerLinearString = registration::OverloadRegister < StringToRawComposer, void, LinearString < > >(StringToRawComposer::compose);
 
 } /* namespace automaton */
 
diff --git a/alib2raw/src/tree/TreeToRawComposer.cpp b/alib2raw/src/tree/TreeToRawComposer.cpp
index 4da3676850e01abf2694ece9cdd6b4387305b1e7..1e7fd0c1944d522e00c612e2206cc79b18e59790 100644
--- a/alib2raw/src/tree/TreeToRawComposer.cpp
+++ b/alib2raw/src/tree/TreeToRawComposer.cpp
@@ -9,6 +9,8 @@
 #include <tree/TreeClasses.h>
 #include "TreeToRawComposer.h"
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace tree {
 
 void TreeToRawComposer::compose(std::deque<sax::Token>& out, const Tree& tree) {
@@ -20,7 +22,7 @@ void TreeToRawComposer::compose(std::deque<sax::Token>& out, const RankedTree <
 	composeNode(out, tree.getContent());
 }
 
-auto TreeToRawComposerRankedTree = TreeToRawComposer::RegistratorWrapper<void, RankedTree < > >(TreeToRawComposer::compose);
+auto TreeToRawComposerRankedTree = registration::OverloadRegister < TreeToRawComposer, void, RankedTree < > >(TreeToRawComposer::compose);
 
 template < class SymbolType, class RankType >
 void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedTree < SymbolType, RankType > & tree) {
@@ -28,7 +30,7 @@ void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedT
 	composePrefixRankedNotation(out, i, tree.getContent());
 }
 
-auto TreeToRawComposerPrefixRankedTree = TreeToRawComposer::RegistratorWrapper<void, PrefixRankedTree < > >(TreeToRawComposer::compose);
+auto TreeToRawComposerPrefixRankedTree = registration::OverloadRegister < TreeToRawComposer, void, PrefixRankedTree < > >(TreeToRawComposer::compose);
 
 template < class SymbolType >
 void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedBarTree < SymbolType > & tree) {
@@ -36,14 +38,14 @@ void TreeToRawComposer::compose(std::deque<sax::Token>& out, const PrefixRankedB
 	composePrefixRankedBarNotation(out, i, tree.getContent());
 }
 
-auto TreeToRawComposerPrefixRankedBarTree = TreeToRawComposer::RegistratorWrapper<void, PrefixRankedBarTree < > >(TreeToRawComposer::compose);
+auto TreeToRawComposerPrefixRankedBarTree = registration::OverloadRegister < TreeToRawComposer, void, PrefixRankedBarTree < > >(TreeToRawComposer::compose);
 
 template < class SymbolType >
 void TreeToRawComposer::compose(std::deque<sax::Token>& out, const UnrankedTree < SymbolType > & tree) {
 	composeNode(out, tree.getContent());
 }
 
-auto TreeToRawComposerUnrankedTree = TreeToRawComposer::RegistratorWrapper<void, UnrankedTree < > >(TreeToRawComposer::compose);
+auto TreeToRawComposerUnrankedTree = registration::OverloadRegister < TreeToRawComposer, void, UnrankedTree < > >(TreeToRawComposer::compose);
 
 } /* namespace automaton */
 
diff --git a/alib2str/src/automaton/AutomatonToStringComposer.cpp b/alib2str/src/automaton/AutomatonToStringComposer.cpp
index f0839dc9b3fb631a961f58472afae2103e1aa0c2..ed609149b9150c5709e7c57317aca78d176f6b6f 100644
--- a/alib2str/src/automaton/AutomatonToStringComposer.cpp
+++ b/alib2str/src/automaton/AutomatonToStringComposer.cpp
@@ -11,6 +11,7 @@
 #include "automaton/FSM/NFA.h"
 #include "automaton/FSM/MultiInitialStateNFA.h"
 #include "automaton/FSM/EpsilonNFA.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace automaton {
 
@@ -39,8 +40,8 @@ void AutomatonToStringComposer::compose(std::ostream& out, const DFA < SymbolTyp
 	}
 }
 
-auto AutomatonToStringComposerDFA = AutomatonToStringComposer::RegistratorWrapper<void, DFA < > >(AutomatonToStringComposer::compose);
-auto ObjectToStringComposerDFA = alib::ObjectBaseDispatcher::RegistratorWrapper<void, DFA < > >( AutomatonToStringComposer::compose);
+auto AutomatonToStringComposerDFA = registration::OverloadRegister < AutomatonToStringComposer, void, DFA < > >(AutomatonToStringComposer::compose);
+auto ObjectToStringComposerDFA = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, DFA < > >( AutomatonToStringComposer::compose);
 
 template < class SymbolType, class StateType >
 void AutomatonToStringComposer::compose(std::ostream& out, const NFA < SymbolType, StateType > & automaton) {
@@ -67,8 +68,8 @@ void AutomatonToStringComposer::compose(std::ostream& out, const NFA < SymbolTyp
 	}
 }
 
-auto AutomatonToStringComposerNFA = AutomatonToStringComposer::RegistratorWrapper<void, NFA < > >(AutomatonToStringComposer::compose);
-auto ObjectToStringComposerNFA = alib::ObjectBaseDispatcher::RegistratorWrapper<void, NFA < > >( AutomatonToStringComposer::compose);
+auto AutomatonToStringComposerNFA = registration::OverloadRegister < AutomatonToStringComposer, void, NFA < > >(AutomatonToStringComposer::compose);
+auto ObjectToStringComposerNFA = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, NFA < > >( AutomatonToStringComposer::compose);
 
 template < class SymbolType, class StateType >
 void AutomatonToStringComposer::compose(std::ostream& out, const MultiInitialStateNFA < SymbolType, StateType > & automaton) {
@@ -95,8 +96,8 @@ void AutomatonToStringComposer::compose(std::ostream& out, const MultiInitialSta
 	}
 }
 
-auto AutomatonToStringComposerMultiInitialStateNFA = AutomatonToStringComposer::RegistratorWrapper<void, MultiInitialStateNFA < > >(AutomatonToStringComposer::compose);
-auto ObjectToStringComposerMultiInitialStateNFA = alib::ObjectBaseDispatcher::RegistratorWrapper<void, MultiInitialStateNFA < > >( AutomatonToStringComposer::compose);
+auto AutomatonToStringComposerMultiInitialStateNFA = registration::OverloadRegister < AutomatonToStringComposer, void, MultiInitialStateNFA < > >(AutomatonToStringComposer::compose);
+auto ObjectToStringComposerMultiInitialStateNFA = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, MultiInitialStateNFA < > >( AutomatonToStringComposer::compose);
 
 template < class SymbolType, class EpsilonType, class StateType >
 void AutomatonToStringComposer::compose(std::ostream& out, const EpsilonNFA < SymbolType, EpsilonType, StateType > & automaton) {
@@ -124,13 +125,13 @@ void AutomatonToStringComposer::compose(std::ostream& out, const EpsilonNFA < Sy
 	}
 }
 
-auto AutomatonToStringComposerEpsilonNFA = AutomatonToStringComposer::RegistratorWrapper<void, EpsilonNFA < > >(AutomatonToStringComposer::compose);
-auto ObjectToStringComposerEpsilonNFA = alib::ObjectBaseDispatcher::RegistratorWrapper<void, EpsilonNFA < > >( AutomatonToStringComposer::compose);
+auto AutomatonToStringComposerEpsilonNFA = registration::OverloadRegister < AutomatonToStringComposer, void, EpsilonNFA < > >(AutomatonToStringComposer::compose);
+auto ObjectToStringComposerEpsilonNFA = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, EpsilonNFA < > >( AutomatonToStringComposer::compose);
 
 void AutomatonToStringComposer::compose(std::ostream& output, const Automaton& automaton) {
 	dispatch(output, automaton.getData());
 }
 
-auto ObjectToStringComposerAutomaton = alib::WrapperBaseDispatcher::RegistratorWrapper<void, Automaton>(AutomatonToStringComposer::compose);
+auto ObjectToStringComposerAutomaton = registration::OverloadRegister < alib::WrapperBaseDispatcher, void, Automaton>(AutomatonToStringComposer::compose);
 
 } /* namespace automaton */
diff --git a/alib2str/src/grammar/GrammarToStringComposer.cpp b/alib2str/src/grammar/GrammarToStringComposer.cpp
index 1bfbf55ba3e3ab7666f6014aa82d634ca64cb166..89f3b8fc7397c7b35f8db6dd3501045c9168a5a4 100644
--- a/alib2str/src/grammar/GrammarToStringComposer.cpp
+++ b/alib2str/src/grammar/GrammarToStringComposer.cpp
@@ -7,6 +7,7 @@
 
 #include "GrammarToStringComposer.h"
 #include "grammar/GrammarClasses.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace grammar {
 
@@ -14,7 +15,7 @@ void GrammarToStringComposer::compose(std::ostream& output, const Grammar& gramm
 	dispatch(output, grammar.getData());
 }
 
-auto ObjectToStringComposerGrammar = alib::WrapperBaseDispatcher::RegistratorWrapper<void, Grammar>(GrammarToStringComposer::compose);
+auto ObjectToStringComposerGrammar = registration::OverloadRegister < alib::WrapperBaseDispatcher, void, Grammar>(GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const LeftLG < SymbolType > & grammar) {
@@ -22,8 +23,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const LeftLG < Symbo
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerLeftLG = GrammarToStringComposer::RegistratorWrapper<void, LeftLG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerLeftLG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, LeftLG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerLeftLG = registration::OverloadRegister < GrammarToStringComposer, void, LeftLG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerLeftLG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, LeftLG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const LeftRG < SymbolType > & grammar) {
@@ -31,8 +32,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const LeftRG < Symbo
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerLeftRG = GrammarToStringComposer::RegistratorWrapper<void, LeftRG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerLeftRG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, LeftRG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerLeftRG = registration::OverloadRegister < GrammarToStringComposer, void, LeftRG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerLeftRG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, LeftRG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const RightLG < SymbolType > & grammar) {
@@ -40,8 +41,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const RightLG < Symb
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerRightLG = GrammarToStringComposer::RegistratorWrapper<void, RightLG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerRightLG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, RightLG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerRightLG = registration::OverloadRegister < GrammarToStringComposer, void, RightLG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerRightLG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, RightLG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const RightRG < SymbolType > & grammar) {
@@ -49,8 +50,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const RightRG < Symb
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerRightRG = GrammarToStringComposer::RegistratorWrapper<void, RightRG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerRightRG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, RightRG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerRightRG = registration::OverloadRegister < GrammarToStringComposer, void, RightRG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerRightRG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, RightRG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const LG < SymbolType > & grammar) {
@@ -58,8 +59,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const LG < SymbolTyp
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerLG = GrammarToStringComposer::RegistratorWrapper<void, LG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerLG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, LG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerLG = registration::OverloadRegister < GrammarToStringComposer, void, LG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerLG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, LG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const CFG < SymbolType > & grammar) {
@@ -67,8 +68,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const CFG < SymbolTy
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerCFG = GrammarToStringComposer::RegistratorWrapper<void, CFG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerCFG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, CFG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerCFG = registration::OverloadRegister < GrammarToStringComposer, void, CFG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerCFG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, CFG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const EpsilonFreeCFG < SymbolType > & grammar) {
@@ -76,8 +77,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const EpsilonFreeCFG
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerEpsilonFreeCFG = GrammarToStringComposer::RegistratorWrapper<void, EpsilonFreeCFG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerEpsilonFreeCFG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, EpsilonFreeCFG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerEpsilonFreeCFG = registration::OverloadRegister < GrammarToStringComposer, void, EpsilonFreeCFG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerEpsilonFreeCFG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, EpsilonFreeCFG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const CNF < SymbolType > & grammar) {
@@ -85,8 +86,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const CNF < SymbolTy
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerCNF = GrammarToStringComposer::RegistratorWrapper<void, CNF < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerCNF = alib::ObjectBaseDispatcher::RegistratorWrapper<void, CNF < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerCNF = registration::OverloadRegister < GrammarToStringComposer, void, CNF < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerCNF = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, CNF < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const GNF < SymbolType > & grammar) {
@@ -94,8 +95,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const GNF < SymbolTy
 	composeCFLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerGNF = GrammarToStringComposer::RegistratorWrapper<void, GNF < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerGNF = alib::ObjectBaseDispatcher::RegistratorWrapper<void, GNF < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerGNF = registration::OverloadRegister < GrammarToStringComposer, void, GNF < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerGNF = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, GNF < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const CSG < SymbolType > & grammar) {
@@ -103,8 +104,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const CSG < SymbolTy
 	composePreservingCSLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerCSG = GrammarToStringComposer::RegistratorWrapper<void, CSG < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerCSG = alib::ObjectBaseDispatcher::RegistratorWrapper<void, CSG < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerCSG = registration::OverloadRegister < GrammarToStringComposer, void, CSG < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerCSG = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, CSG < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const NonContractingGrammar < SymbolType > & grammar) {
@@ -112,8 +113,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const NonContracting
 	composeCSLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerNonContractingGrammar = GrammarToStringComposer::RegistratorWrapper<void, NonContractingGrammar < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerNonContractingGrammar = alib::ObjectBaseDispatcher::RegistratorWrapper<void, NonContractingGrammar < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerNonContractingGrammar = registration::OverloadRegister < GrammarToStringComposer, void, NonContractingGrammar < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerNonContractingGrammar = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, NonContractingGrammar < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const ContextPreservingUnrestrictedGrammar < SymbolType > & grammar) {
@@ -121,8 +122,8 @@ void GrammarToStringComposer::compose(std::ostream& output, const ContextPreserv
 	composePreservingCSLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerContextPreservingUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerContextPreservingUnrestrictedGrammar = alib::ObjectBaseDispatcher::RegistratorWrapper<void, ContextPreservingUnrestrictedGrammar < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerContextPreservingUnrestructedGrammar = registration::OverloadRegister < GrammarToStringComposer, void, ContextPreservingUnrestrictedGrammar < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerContextPreservingUnrestrictedGrammar = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, ContextPreservingUnrestrictedGrammar < > >( GrammarToStringComposer::compose);
 
 template<class SymbolType>
 void GrammarToStringComposer::compose(std::ostream& output, const UnrestrictedGrammar < SymbolType > & grammar) {
@@ -130,7 +131,7 @@ void GrammarToStringComposer::compose(std::ostream& output, const UnrestrictedGr
 	composeCSLikeGrammar(output, grammar);
 }
 
-auto GrammarToStringComposerUnrestructedGrammar = GrammarToStringComposer::RegistratorWrapper<void, UnrestrictedGrammar < > >(GrammarToStringComposer::compose);
-auto ObjectToStringComposerUnrestrictedGrammar = alib::ObjectBaseDispatcher::RegistratorWrapper<void, UnrestrictedGrammar < > >( GrammarToStringComposer::compose);
+auto GrammarToStringComposerUnrestructedGrammar = registration::OverloadRegister < GrammarToStringComposer, void, UnrestrictedGrammar < > >(GrammarToStringComposer::compose);
+auto ObjectToStringComposerUnrestrictedGrammar = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, UnrestrictedGrammar < > >( GrammarToStringComposer::compose);
 
 }
diff --git a/alib2str/src/object/ObjectToStringComposer.cpp b/alib2str/src/object/ObjectToStringComposer.cpp
index 410bbbbc63bde64ac05ec12667ad2f76c57bdf99..e899b43ce174fa7bd8c64ac87d2a559c57bc2c00 100644
--- a/alib2str/src/object/ObjectToStringComposer.cpp
+++ b/alib2str/src/object/ObjectToStringComposer.cpp
@@ -7,6 +7,7 @@
 
 #include "ObjectToStringComposer.h"
 #include "../StringApi.hpp"
+#include <registration/AlgoRegistration.hpp>
 
 namespace alib {
 
@@ -24,25 +25,25 @@ void ObjectToStringComposer::compose(std::ostream& out, const Object& object) {
 	compose( out, object.getData ( ) );
 }
 
-auto ObjectToStringComposerObject = WrapperBaseDispatcher::RegistratorWrapper<void, Object>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerObject = registration::OverloadRegister < WrapperBaseDispatcher, void, Object>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const primitive::Primitive& primitive) {
 	compose(out, primitive.getData());
 }
 
-auto ObjectToStringComposerPrimitive = WrapperBaseDispatcher::RegistratorWrapper<void, primitive::Primitive>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerPrimitive = registration::OverloadRegister < WrapperBaseDispatcher, void, primitive::Primitive>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& output, const label::Label& label) {
 	compose(output, label.getData());
 }
 
-auto ObjectToStringComposerLabel = WrapperBaseDispatcher::RegistratorWrapper<void, label::Label>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerLabel = registration::OverloadRegister < WrapperBaseDispatcher, void, label::Label>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::Symbol& symbol) {
 	compose(out, symbol.getData());
 }
 
-auto ObjectToStringComposerSymbol = WrapperBaseDispatcher::RegistratorWrapper<void, alphabet::Symbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerSymbol = registration::OverloadRegister < WrapperBaseDispatcher, void, alphabet::Symbol>(ObjectToStringComposer::compose);
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -50,19 +51,19 @@ void ObjectToStringComposer::compose(std::ostream& out, const Void&) {
 	out << "Void";
 }
 
-auto ObjectToStringComposerVoid = ObjectBaseDispatcher::RegistratorWrapper<void, Void>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerVoid = registration::OverloadRegister < ObjectBaseDispatcher, void, Void>(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerAnyObjectSet = ObjectBaseDispatcher::RegistratorWrapper<void, AnyObject < std::set < Object > > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerAnyObjectSet = registration::OverloadRegister < ObjectBaseDispatcher, void, AnyObject < std::set < Object > > >(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerAnyObjectPair = ObjectBaseDispatcher::RegistratorWrapper<void, AnyObject < std::pair < Object, Object > > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerAnyObjectPair = registration::OverloadRegister < ObjectBaseDispatcher, void, AnyObject < std::pair < Object, Object > > >(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerAnyObjectUnsigned = ObjectBaseDispatcher::RegistratorWrapper<void, AnyObject < unsigned > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerAnyObjectUnsigned = registration::OverloadRegister < ObjectBaseDispatcher, void, AnyObject < unsigned > >(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerObjectsPair = ObjectBaseDispatcher::RegistratorWrapper<void, container::ObjectsPair < Object, Object > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerObjectsPair = registration::OverloadRegister < ObjectBaseDispatcher, void, container::ObjectsPair < Object, Object > >(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerObjectsSet = ObjectBaseDispatcher::RegistratorWrapper<void, container::ObjectsSet < Object > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerObjectsSet = registration::OverloadRegister < ObjectBaseDispatcher, void, container::ObjectsSet < Object > >(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerObjectsVector = ObjectBaseDispatcher::RegistratorWrapper<void, container::ObjectsVector < Object > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerObjectsVector = registration::OverloadRegister < ObjectBaseDispatcher, void, container::ObjectsVector < Object > >(ObjectToStringComposer::compose);
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
@@ -70,25 +71,25 @@ void ObjectToStringComposer::compose(std::ostream& out, const primitive::String&
 	out << primitive.getData();
 }
 
-auto ObjectToStringComposerString = ObjectBaseDispatcher::RegistratorWrapper<void, primitive::String>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerString = registration::OverloadRegister < ObjectBaseDispatcher, void, primitive::String>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const primitive::Character& primitive) {
 	out << primitive.getData();
 }
 
-auto ObjectToStringComposerCharacter = ObjectBaseDispatcher::RegistratorWrapper<void, primitive::Character>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerCharacter = registration::OverloadRegister < ObjectBaseDispatcher, void, primitive::Character>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const primitive::Integer& primitive) {
 	out << primitive.getData();
 }
 
-auto ObjectToStringComposerInteger = ObjectBaseDispatcher::RegistratorWrapper<void, primitive::Integer>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerInteger = registration::OverloadRegister < ObjectBaseDispatcher, void, primitive::Integer>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const primitive::Unsigned& primitive) {
 	out << primitive.getData();
 }
 
-auto ObjectToStringComposerUnsigned = ObjectBaseDispatcher::RegistratorWrapper<void, primitive::Unsigned>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerUnsigned = registration::OverloadRegister < ObjectBaseDispatcher, void, primitive::Unsigned>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, unsigned primitive) {
 	out << primitive;
@@ -98,7 +99,7 @@ void ObjectToStringComposer::compose(std::ostream& out, const primitive::Bool& p
 	out << (primitive.getData() ? "true" : "false");
 }
 
-auto ObjectToStringComposerBool = ObjectBaseDispatcher::RegistratorWrapper<void, primitive::Bool>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerBool = registration::OverloadRegister < ObjectBaseDispatcher, void, primitive::Bool>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::LabeledSymbol& symbol) {
 	compose(out, symbol.getLabel());
@@ -110,19 +111,19 @@ void ObjectToStringComposer::compose(std::ostream& out, const label::PrimitiveLa
 	compose(out, label.getData());
 }
 
-auto ObjectToStringComposerPrimitiveLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::PrimitiveLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerPrimitiveLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::PrimitiveLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::HexavigesimalLabel& label) {
 	out << (std::string) label;
 }
 
-auto ObjectToStringComposerHexavigesimalLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::HexavigesimalLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerHexavigesimalLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::HexavigesimalLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::ObjectLabel& label) {
 	out << (std::string) label;
 }
 
-auto ObjectToStringComposerObjectLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::ObjectLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerObjectLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::ObjectLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::UniqueLabel& label) {
 	out << '<';
@@ -132,75 +133,75 @@ void ObjectToStringComposer::compose(std::ostream& out, const label::UniqueLabel
 	out << '>';
 }
 
-auto ObjectToStringComposerUniqueLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::UniqueLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerUniqueLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::UniqueLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::FailStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto ObjectToStringComposerFailStateLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::FailStateLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerFailStateLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::FailStateLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::InitialStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto ObjectToStringComposerInitialStateLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::InitialStateLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerInitialStateLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::InitialStateLabel>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const label::FinalStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto ObjectToStringComposerFinalStateLabel = ObjectBaseDispatcher::RegistratorWrapper<void, label::FinalStateLabel>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerFinalStateLabel = registration::OverloadRegister < ObjectBaseDispatcher, void, label::FinalStateLabel>(ObjectToStringComposer::compose);
 
 // ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-auto ObjectToStringComposerLabeledSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::LabeledSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerLabeledSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::LabeledSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::BlankSymbol&) {
 	out << "#B";
 }
 
-auto ObjectToStringComposerBlankSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::BlankSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerBlankSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::BlankSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::BottomOfTheStackSymbol&) {
 	out << "#T";
 }
 
-auto ObjectToStringComposerBottomOfTheStackSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::BottomOfTheStackSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerBottomOfTheStackSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::BottomOfTheStackSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::EndSymbol&) {
 	out << "#$";
 }
 
-auto ObjectToStringComposerEndSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::EndSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerEndSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::EndSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::StartSymbol&) {
 	out << "#^";
 }
 
-auto ObjectToStringComposerStartSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::StartSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerStartSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::StartSymbol>(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerRankedSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::RankedSymbol < > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerRankedSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::RankedSymbol < > >(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::BarSymbol&) {
 	out << "#|";
 }
 
-auto ObjectToStringComposerBarSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::BarSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerBarSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::BarSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::VariablesBarSymbol&) {
 	out << "#/";
 }
 
-auto ObjectToStringComposerVariablesBarSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::VariablesBarSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerVariablesBarSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::VariablesBarSymbol>(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::SubtreeWildcardSymbol&) {
 	out << "#S";
 }
 
-auto ObjectToStringComposerSubtreeWildcardSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::SubtreeWildcardSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerSubtreeWildcardSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::SubtreeWildcardSymbol>(ObjectToStringComposer::compose);
 
-auto ObjectToStringComposerNonlinearVariableSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::NonlinearVariableSymbol < > >(ObjectToStringComposer::compose);
+auto ObjectToStringComposerNonlinearVariableSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::NonlinearVariableSymbol < > >(ObjectToStringComposer::compose);
 
 void ObjectToStringComposer::compose(std::ostream& out, const alphabet::UniqueSymbol& symbol) {
 	out << '<';
@@ -210,6 +211,6 @@ void ObjectToStringComposer::compose(std::ostream& out, const alphabet::UniqueSy
 	out << '>';
 }
 
-auto ObjectToStringComposerUniqueSymbol = ObjectBaseDispatcher::RegistratorWrapper<void, alphabet::UniqueSymbol>(ObjectToStringComposer::compose);
+auto ObjectToStringComposerUniqueSymbol = registration::OverloadRegister < ObjectBaseDispatcher, void, alphabet::UniqueSymbol>(ObjectToStringComposer::compose);
 
 } /* namespace alib */
diff --git a/alib2str/src/regexp/RegExpToStringComposer.cpp b/alib2str/src/regexp/RegExpToStringComposer.cpp
index de9c182b7e7c942a8e721e2cf1717140af494976..6a5d08dc3e73682c68fded40b17afe80d3e17cba 100644
--- a/alib2str/src/regexp/RegExpToStringComposer.cpp
+++ b/alib2str/src/regexp/RegExpToStringComposer.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "RegExpToStringComposer.h"
+#include <registration/AlgoRegistration.hpp>
 
 namespace regexp {
 
@@ -14,21 +15,21 @@ void RegExpToStringComposer::compose(std::ostream& output, const UnboundedRegExp
 	RegExpToStringComposer::compose ( output, regexp.getRegExp ( ) );
 }
 
-auto RegExpToStringComposerUnboundedRegExp = RegExpToStringComposer::RegistratorWrapper<void, UnboundedRegExp < > >(RegExpToStringComposer::compose);
-auto ObjectToStringComposerUnboundedRegExp = alib::ObjectBaseDispatcher::RegistratorWrapper<void, UnboundedRegExp < > >( RegExpToStringComposer::compose);
+auto RegExpToStringComposerUnboundedRegExp = registration::OverloadRegister < RegExpToStringComposer, void, UnboundedRegExp < > >(RegExpToStringComposer::compose);
+auto ObjectToStringComposerUnboundedRegExp = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, UnboundedRegExp < > >( RegExpToStringComposer::compose);
 
 template < class SymbolType >
 void RegExpToStringComposer::compose(std::ostream& output, const FormalRegExp < SymbolType > & regexp) {
 	RegExpToStringComposer::compose ( output, regexp.getRegExp ( ) );
 }
 
-auto RegExpToStringComposerFormalRegExp = RegExpToStringComposer::RegistratorWrapper<void, FormalRegExp < > >(RegExpToStringComposer::compose);
-auto ObjectToStringComposerFormalRegExp = alib::ObjectBaseDispatcher::RegistratorWrapper<void, FormalRegExp < > >( RegExpToStringComposer::compose);
+auto RegExpToStringComposerFormalRegExp = registration::OverloadRegister < RegExpToStringComposer, void, FormalRegExp < > >(RegExpToStringComposer::compose);
+auto ObjectToStringComposerFormalRegExp = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, FormalRegExp < > >( RegExpToStringComposer::compose);
 
 void RegExpToStringComposer::compose(std::ostream& output, const RegExp& regexp) {
 	dispatch(output, regexp.getData());
 }
 
-auto ObjectToStringComposerRegExp = alib::WrapperBaseDispatcher::RegistratorWrapper<void, RegExp>(RegExpToStringComposer::compose);
+auto ObjectToStringComposerRegExp = registration::OverloadRegister < alib::WrapperBaseDispatcher, void, RegExp>(RegExpToStringComposer::compose);
 
 } /* namespace regexp */
diff --git a/alib2str/src/string/StringToStringComposer.cpp b/alib2str/src/string/StringToStringComposer.cpp
index 8bc76c2faa1f51285d519cd700146c0066435929..7b09f744d23b917b3eeda6bd624a006b1e0a5a14 100644
--- a/alib2str/src/string/StringToStringComposer.cpp
+++ b/alib2str/src/string/StringToStringComposer.cpp
@@ -12,6 +12,8 @@
 #include "string/LinearString.h"
 #include "string/Epsilon.h"
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace string {
 
 template < class SymbolType >
@@ -30,8 +32,8 @@ void StringToStringComposer::compose ( std::ostream & out, const CyclicString <
 	out << ">";
 }
 
-auto StringToStringComposerCyclicString = StringToStringComposer::RegistratorWrapper < void, CyclicString < > > ( StringToStringComposer::compose );
-auto ObjectToStringComposerCyclicString = alib::ObjectBaseDispatcher::RegistratorWrapper<void, CyclicString < > >( StringToStringComposer::compose);
+auto StringToStringComposerCyclicString = registration::OverloadRegister < StringToStringComposer, void, CyclicString < > > ( StringToStringComposer::compose );
+auto ObjectToStringComposerCyclicString = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, CyclicString < > >( StringToStringComposer::compose);
 
 template < class SymbolType >
 void StringToStringComposer::compose ( std::ostream & out, const LinearString < SymbolType > & string ) {
@@ -49,21 +51,21 @@ void StringToStringComposer::compose ( std::ostream & out, const LinearString <
 	out << "\"";
 }
 
-auto StringToStringComposerLinearString = StringToStringComposer::RegistratorWrapper < void, LinearString < > > ( StringToStringComposer::compose );
-auto ObjectToStringComposerLinearString = alib::ObjectBaseDispatcher::RegistratorWrapper<void, LinearString < > >( StringToStringComposer::compose);
+auto StringToStringComposerLinearString = registration::OverloadRegister < StringToStringComposer, void, LinearString < > > ( StringToStringComposer::compose );
+auto ObjectToStringComposerLinearString = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, LinearString < > >( StringToStringComposer::compose);
 
 template < class SymbolType >
 void StringToStringComposer::compose ( std::ostream & out, const Epsilon < SymbolType > & ) {
 	out << "#E";
 }
 
-auto StringToStringComposerEpsilon = StringToStringComposer::RegistratorWrapper < void, Epsilon < > > ( StringToStringComposer::compose );
-auto ObjectToStringComposerEpsilon = alib::ObjectBaseDispatcher::RegistratorWrapper<void, Epsilon < > >( StringToStringComposer::compose);
+auto StringToStringComposerEpsilon = registration::OverloadRegister < StringToStringComposer, void, Epsilon < > > ( StringToStringComposer::compose );
+auto ObjectToStringComposerEpsilon = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, Epsilon < > >( StringToStringComposer::compose);
 
 void StringToStringComposer::compose ( std::ostream & out, const String & string ) {
 	dispatch ( out, string.getData ( ) );
 }
 
-auto ObjectToStringComposerString = alib::WrapperBaseDispatcher::RegistratorWrapper<void, String>(StringToStringComposer::compose);
+auto ObjectToStringComposerString = registration::OverloadRegister < alib::WrapperBaseDispatcher, void, String>(StringToStringComposer::compose);
 
 } /* namespace string */
diff --git a/alib2str/src/tree/TreeToStringComposer.cpp b/alib2str/src/tree/TreeToStringComposer.cpp
index 4c0b79d4713d6288eb732eb297ef5df8097e21bc..cff19603f72e9113f9dd439e0e5630279b6fa934 100644
--- a/alib2str/src/tree/TreeToStringComposer.cpp
+++ b/alib2str/src/tree/TreeToStringComposer.cpp
@@ -11,6 +11,8 @@
 #include <tree/unranked/UnrankedTree.h>
 #include <tree/unranked/UnrankedPattern.h>
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace tree {
 
 template < class SymbolType, class RankType >
@@ -18,37 +20,37 @@ void TreeToStringComposer::compose ( std::ostream & out, const RankedTree < Symb
 	compose ( out, tree.getContent ( ) );
 }
 
-auto StringToStringComposerRankedTree = TreeToStringComposer::RegistratorWrapper < void, RankedTree < > > ( TreeToStringComposer::compose );
-auto ObjectToStringComposerRankedTree = alib::ObjectBaseDispatcher::RegistratorWrapper<void, RankedTree < > >(TreeToStringComposer::compose);
+auto StringToStringComposerRankedTree = registration::OverloadRegister < TreeToStringComposer, void, RankedTree < > > ( TreeToStringComposer::compose );
+auto ObjectToStringComposerRankedTree = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, RankedTree < > >(TreeToStringComposer::compose);
 
 template < class SymbolType, class RankType >
 void TreeToStringComposer::compose ( std::ostream & out, const RankedPattern < SymbolType, RankType > & tree ) {
 	compose ( out, tree.getSubtreeWildcard ( ), tree.getContent ( ) );
 }
 
-auto StringToStringComposerRankedPattern = TreeToStringComposer::RegistratorWrapper < void, RankedPattern < > > ( TreeToStringComposer::compose );
-auto ObjectToStringComposerRankedPattern = alib::ObjectBaseDispatcher::RegistratorWrapper<void, RankedPattern < > >(TreeToStringComposer::compose);
+auto StringToStringComposerRankedPattern = registration::OverloadRegister < TreeToStringComposer, void, RankedPattern < > > ( TreeToStringComposer::compose );
+auto ObjectToStringComposerRankedPattern = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, RankedPattern < > >(TreeToStringComposer::compose);
 
 template < class SymbolType >
 void TreeToStringComposer::compose ( std::ostream & out, const UnrankedTree < SymbolType > & tree ) {
 	compose ( out, tree.getContent ( ) );
 }
 
-auto StringToStringComposerUnrankedTree = TreeToStringComposer::RegistratorWrapper < void, UnrankedTree < > > ( TreeToStringComposer::compose );
-auto ObjectToStringComposerUnrankedTree = alib::ObjectBaseDispatcher::RegistratorWrapper<void, UnrankedTree < > >(TreeToStringComposer::compose);
+auto StringToStringComposerUnrankedTree = registration::OverloadRegister < TreeToStringComposer, void, UnrankedTree < > > ( TreeToStringComposer::compose );
+auto ObjectToStringComposerUnrankedTree = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, UnrankedTree < > >(TreeToStringComposer::compose);
 
 template < class SymbolType >
 void TreeToStringComposer::compose ( std::ostream & out, const UnrankedPattern < SymbolType > & tree ) {
 	compose ( out, tree.getSubtreeWildcard ( ), tree.getContent ( ) );
 }
 
-auto StringToStringComposerUnrankedPattern = TreeToStringComposer::RegistratorWrapper < void, UnrankedPattern < > > ( TreeToStringComposer::compose );
-auto ObjectToStringComposerUnrankedPattern = alib::ObjectBaseDispatcher::RegistratorWrapper<void, UnrankedPattern < > >(TreeToStringComposer::compose);
+auto StringToStringComposerUnrankedPattern = registration::OverloadRegister < TreeToStringComposer, void, UnrankedPattern < > > ( TreeToStringComposer::compose );
+auto ObjectToStringComposerUnrankedPattern = registration::OverloadRegister < alib::ObjectBaseDispatcher, void, UnrankedPattern < > >(TreeToStringComposer::compose);
 
 void TreeToStringComposer::compose ( std::ostream & out, const Tree & tree ) {
 	dispatch ( out, tree.getData ( ) );
 }
 
-auto ObjectToStringComposerTree = alib::WrapperBaseDispatcher::RegistratorWrapper<void, Tree>(TreeToStringComposer::compose);
+auto ObjectToStringComposerTree = registration::OverloadRegister < alib::WrapperBaseDispatcher, void, Tree>(TreeToStringComposer::compose);
 
 } /* namespace tree */
diff --git a/alib2str_experimental/src/graph/GraphToStringComposer.cpp b/alib2str_experimental/src/graph/GraphToStringComposer.cpp
index c8f3c23aebe4d087330e9b2a8321918d5fe66868..a74ccf1fa51ccc053dc62a2c99039b36e7b93dbd 100644
--- a/alib2str_experimental/src/graph/GraphToStringComposer.cpp
+++ b/alib2str_experimental/src/graph/GraphToStringComposer.cpp
@@ -11,6 +11,8 @@
 #include <StringApi.hpp>
 #include <label/LabelStringApi.hpp>
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace graph {
 
 void GraphToStringComposer::compose(std::ostream &out, const Graph &graph)
@@ -34,7 +36,7 @@ void GraphToStringComposer::compose(std::ostream& out, const DirectedGraph &grap
 	composeEdgeValues(out, graph);
 }
 
-//auto GraphToStringComposerDirectedGraph = GraphToStringComposer::RegistratorWrapper<void, DirectedGraph>(GraphToStringComposer::compose);
+//auto GraphToStringComposerDirectedGraph = registration::OverloadRegister < GraphToStringComposer, void, DirectedGraph>(GraphToStringComposer::compose);
 
 void GraphToStringComposer::compose(std::ostream& out, const UndirectedGraph &graph)
 {
@@ -50,7 +52,7 @@ void GraphToStringComposer::compose(std::ostream& out, const UndirectedGraph &gr
 	composeEdgeValues(out, graph);
 }
 
-//auto> GraphToStringComposerUndirectedGraph = GraphToStringComposer::RegistratorWrapper<void, UndirectedGraph>(GraphToStringComposer::compose);
+//auto> GraphToStringComposerUndirectedGraph = registration::OverloadRegister < GraphToStringComposer, void, UndirectedGraph>(GraphToStringComposer::compose);
 
 
 // !! add graph types/representations
@@ -58,25 +60,25 @@ void composeALDG(std::ostream & out, const AdjacencyListDirectedGraph & graph) {
 	GraphToStringComposer::compose(out, graph);
 }
 
-auto GraphToStringComposerALDG = GraphToStringComposer::RegistratorWrapper<void, AdjacencyListDirectedGraph>(composeALDG);
+auto GraphToStringComposerALDG = registration::OverloadRegister < GraphToStringComposer, void, AdjacencyListDirectedGraph>(composeALDG);
 
 void composeAMDG(std::ostream & out, const AdjacencyMatrixDirectedGraph & graph) {
 	GraphToStringComposer::compose(out, graph);
 }
 
-auto GraphToStringComposerAMDG = GraphToStringComposer::RegistratorWrapper<void, AdjacencyMatrixDirectedGraph>(composeAMDG);
+auto GraphToStringComposerAMDG = registration::OverloadRegister < GraphToStringComposer, void, AdjacencyMatrixDirectedGraph>(composeAMDG);
 
 void composeALUG(std::ostream & out, const AdjacencyListUndirectedGraph & graph) {
 	GraphToStringComposer::compose(out, graph);
 }
 
-auto GraphToStringComposerALUG = GraphToStringComposer::RegistratorWrapper<void, AdjacencyListUndirectedGraph>(composeALUG);
+auto GraphToStringComposerALUG = registration::OverloadRegister < GraphToStringComposer, void, AdjacencyListUndirectedGraph>(composeALUG);
 
 void composeAMUG(std::ostream & out, const AdjacencyMatrixUndirectedGraph & graph) {
 	GraphToStringComposer::compose(out, graph);
 }
 
-auto GraphToStringComposerAMUG = GraphToStringComposer::RegistratorWrapper<void, AdjacencyMatrixUndirectedGraph>(composeAMUG);
+auto GraphToStringComposerAMUG = registration::OverloadRegister < GraphToStringComposer, void, AdjacencyMatrixUndirectedGraph>(composeAMUG);
 
 
 
diff --git a/alib2str_experimental/src/label/LabelToStringComposer.cpp b/alib2str_experimental/src/label/LabelToStringComposer.cpp
index aaccebc5e3f07c5ca9fb9b512053c250e31db9c3..8445aabaa74cd575908bacd9ac48e3dc5598f15e 100644
--- a/alib2str_experimental/src/label/LabelToStringComposer.cpp
+++ b/alib2str_experimental/src/label/LabelToStringComposer.cpp
@@ -18,25 +18,27 @@
 
 #include <StringApi.hpp>
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace label {
 
 void LabelToStringComposer::compose(std::ostream& out, const PrimitiveLabel& label) {
 	alib::stringApi<primitive::Primitive>::compose(out, label.getData());
 }
 
-auto LabelToStringComposerPrimitiveLabel = LabelToStringComposer::RegistratorWrapper<void, PrimitiveLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerPrimitiveLabel = registration::OverloadRegister < LabelToStringComposer, void, PrimitiveLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const HexavigesimalLabel& label) {
 	out << (std::string) label;
 }
 
-auto LabelToStringComposerHexavigesimalLabel = LabelToStringComposer::RegistratorWrapper<void, HexavigesimalLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerHexavigesimalLabel = registration::OverloadRegister < LabelToStringComposer, void, HexavigesimalLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const ObjectLabel& label) {
 	out << (std::string) label;
 }
 
-auto LabelToStringComposerObjectLabel = LabelToStringComposer::RegistratorWrapper<void, ObjectLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerObjectLabel = registration::OverloadRegister < LabelToStringComposer, void, ObjectLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const UniqueLabel& label) {
 	out << '<';
@@ -46,25 +48,25 @@ void LabelToStringComposer::compose(std::ostream& out, const UniqueLabel& label)
 	out << '>';
 }
 
-auto LabelToStringComposerUniqueLabel = LabelToStringComposer::RegistratorWrapper<void, UniqueLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerUniqueLabel = registration::OverloadRegister < LabelToStringComposer, void, UniqueLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const FailStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto LabelToStringComposerFailStateLabel = LabelToStringComposer::RegistratorWrapper<void, FailStateLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerFailStateLabel = registration::OverloadRegister < LabelToStringComposer, void, FailStateLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const InitialStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto LabelToStringComposerInitialStateLabel = LabelToStringComposer::RegistratorWrapper<void, InitialStateLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerInitialStateLabel = registration::OverloadRegister < LabelToStringComposer, void, InitialStateLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& out, const FinalStateLabel& label) {
 	out << (std::string) label;
 }
 
-auto LabelToStringComposerFinalStateLabel = LabelToStringComposer::RegistratorWrapper<void, FinalStateLabel>(LabelToStringComposer::compose);
+auto LabelToStringComposerFinalStateLabel = registration::OverloadRegister < LabelToStringComposer, void, FinalStateLabel>(LabelToStringComposer::compose);
 
 void LabelToStringComposer::compose(std::ostream& output, const Label& label) {
 	dispatch(output, label.getData());
diff --git a/alib2str_experimental/src/primitive/PrimitiveToStringComposer.cpp b/alib2str_experimental/src/primitive/PrimitiveToStringComposer.cpp
index c6fee77ab00c4a1ba0fe62f2b433b5e56bb89a4e..8985c268a1706ed08a4cb583a414047efb99f45f 100644
--- a/alib2str_experimental/src/primitive/PrimitiveToStringComposer.cpp
+++ b/alib2str_experimental/src/primitive/PrimitiveToStringComposer.cpp
@@ -14,6 +14,8 @@
 #include "primitive/Unsigned.h"
 #include "primitive/Bool.h"
 
+#include <registration/AlgoRegistration.hpp>
+
 namespace primitive {
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const String& primitive) {
@@ -30,31 +32,31 @@ void PrimitiveToStringComposer::compose(std::ostream& out, const String& primiti
 	out << '\'' << tmp << '\'';
 }
 
-auto PrimitiveToStringComposerString = PrimitiveToStringComposer::RegistratorWrapper<void, String>(PrimitiveToStringComposer::compose);
+auto PrimitiveToStringComposerString = registration::OverloadRegister < PrimitiveToStringComposer, void, String>(PrimitiveToStringComposer::compose);
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const Character& primitive) {
 	out << primitive.getData();
 }
 
-auto PrimitiveToStringComposerCharacter = PrimitiveToStringComposer::RegistratorWrapper<void, Character>(PrimitiveToStringComposer::compose);
+auto PrimitiveToStringComposerCharacter = registration::OverloadRegister < PrimitiveToStringComposer, void, Character>(PrimitiveToStringComposer::compose);
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const Integer& primitive) {
 	out << primitive.getData();
 }
 
-auto PrimitiveToStringComposerInteger = PrimitiveToStringComposer::RegistratorWrapper<void, Integer>(PrimitiveToStringComposer::compose);
+auto PrimitiveToStringComposerInteger = registration::OverloadRegister < PrimitiveToStringComposer, void, Integer>(PrimitiveToStringComposer::compose);
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const Unsigned& primitive) {
 	out << primitive.getData();
 }
 
-auto PrimitiveToStringComposerUnsigned = PrimitiveToStringComposer::RegistratorWrapper<void, Unsigned>(PrimitiveToStringComposer::compose);
+auto PrimitiveToStringComposerUnsigned = registration::OverloadRegister < PrimitiveToStringComposer, void, Unsigned>(PrimitiveToStringComposer::compose);
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const Bool& primitive) {
 	out << (primitive.getData() ? "true" : "false");
 }
 
-auto PrimitiveToStringComposerBool = PrimitiveToStringComposer::RegistratorWrapper<void, Bool>(PrimitiveToStringComposer::compose);
+auto PrimitiveToStringComposerBool = registration::OverloadRegister < PrimitiveToStringComposer, void, Bool>(PrimitiveToStringComposer::compose);
 
 void PrimitiveToStringComposer::compose(std::ostream& out, const Primitive& primitive) {
 	dispatch(out, primitive.getData());
diff --git a/astat2/src/SizeStat.cpp b/astat2/src/SizeStat.cpp
index 72684d1981395a880ab812da85b412dc2c7e8d92..1c8166680d906f9a7270fe4cb95a5d9997a531d1 100644
--- a/astat2/src/SizeStat.cpp
+++ b/astat2/src/SizeStat.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "SizeStat.h"
+#include <registration/AlgoRegistration.hpp>
 
 void SizeStat::stat ( const container::Container & container ) {
 	dispatch ( container.getData ( ) );
@@ -15,4 +16,4 @@ void SizeStat::stat ( const container::ObjectsSet < > & set ) {
 	std::cout << set.size ( ) << std::endl;
 }
 
-auto SizeStatObjectsSet = SizeStat::RegistratorWrapper < void, container::ObjectsSet < > > ( SizeStat::stat );
+auto SizeStatObjectsSet = registration::OverloadRegister < SizeStat, void, container::ObjectsSet < > > ( SizeStat::stat );