template RightLG grammar

aaccess2/src/GrammarAccess.cpp

@@ -43,7 +43,7 @@ void GrammarAccess::access ( grammar::RightRG & grammar, const GrammarSettings::
 auto GrammarAccessRightRG = GrammarAccess::RegistratorWrapper < void, grammar::RightRG > ( GrammarAccess::access );
-void GrammarAccess::access ( grammar::RightLG & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
+void GrammarAccess::access ( grammar::RightLG < > & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument ) {
 	if ( settings == GrammarSettings::Settings::NONTERMINALS )
 		return handleComponent < grammar::NonterminalAlphabet > ( grammar, operation, argument );
@@ -59,4 +59,4 @@ void GrammarAccess::access ( grammar::RightLG & grammar, const GrammarSettings::
 	throw exception::CommonException ( "Component not available" );
 }
-auto GrammarAccessRightLG = GrammarAccess::RegistratorWrapper < void, grammar::RightLG > ( GrammarAccess::access );
+auto GrammarAccessRightLG = GrammarAccess::RegistratorWrapper < void, grammar::RightLG < > > ( GrammarAccess::access );

aaccess2/src/GrammarAccess.h

@@ -22,7 +22,7 @@ public:
 	static void access ( grammar::Grammar & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
 	static void access ( grammar::RightRG & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
-	static void access ( grammar::RightLG & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
+	static void access ( grammar::RightLG < > & grammar, const GrammarSettings::Settings & settings, const OperationSettings::Settings & operation, std::deque < sax::Token > & argument );
 };
 #endif /* GRAMMAR_ACCESS_H_ */

acompare2/src/GrammarCompare.cpp

@@ -44,7 +44,7 @@ bool GrammarCompare::testCompare(const grammar::LeftRG < > & a, const grammar::L
 			a.getTerminalAlphabet()    == b.getTerminalAlphabet()    ;
 }
-bool GrammarCompare::testCompare(const grammar::RightLG& a, const grammar::RightLG& b) {
+bool GrammarCompare::testCompare(const grammar::RightLG < > & a, const grammar::RightLG < > & b) {
 	return  	a.getNonterminalAlphabet() == b.getNonterminalAlphabet() &&
 			a.getRules()               == b.getRules()               &&
 			a.getInitialSymbol()       == b.getInitialSymbol()       &&
@@ -229,7 +229,7 @@ void GrammarCompare::printCompare(const grammar::LeftRG < > & a, const grammar::
 	}
 }
-void GrammarCompare::printCompare(const grammar::RightLG& a, const grammar::RightLG& b) {
+void GrammarCompare::printCompare(const grammar::RightLG < > & a, const grammar::RightLG < > & b) {
 	std::cout << "GrammarCompareer" << std::endl;
 	if(a.getNonterminalAlphabet() != b.getNonterminalAlphabet()) {
@@ -581,7 +581,7 @@ int GrammarCompare::compare(const grammar::LeftRG < > & a, const grammar::LeftRG
 auto GrammarCompareLeftRG = GrammarCompare::RegistratorWrapper<int, grammar::LeftRG < >, grammar::LeftRG < > >(GrammarCompare::compare);
-int GrammarCompare::compare(const grammar::RightLG& a, const grammar::RightLG& b) {
+int GrammarCompare::compare(const grammar::RightLG < > & a, const grammar::RightLG < > & b) {
 	if(!GrammarCompare::testCompare(a, b)) {
 	  GrammarCompare::printCompare(a, b);
 	  return 1;
@@ -590,7 +590,7 @@ int GrammarCompare::compare(const grammar::RightLG& a, const grammar::RightLG& b
 	}
 }
-auto GrammarCompareRightLG = GrammarCompare::RegistratorWrapper<int, grammar::RightLG, grammar::RightLG>(GrammarCompare::compare);
+auto GrammarCompareRightLG = GrammarCompare::RegistratorWrapper<int, grammar::RightLG < >, grammar::RightLG < > >(GrammarCompare::compare);
 int GrammarCompare::compare(const grammar::RightRG& a, const grammar::RightRG& b) {
 	if(!GrammarCompare::testCompare(a, b)) {

acompare2/src/GrammarCompare.h

@@ -26,8 +26,8 @@ private:
 	static bool testCompare(const grammar::LeftRG < > & a, const grammar::LeftRG < > & b);
 	static void printCompare(const grammar::LeftRG < > & a, const grammar::LeftRG < > & b);
-	static bool testCompare(const grammar::RightLG& a, const grammar::RightLG& b);
-	static void printCompare(const grammar::RightLG& a, const grammar::RightLG& b);
+	static bool testCompare(const grammar::RightLG < > & a, const grammar::RightLG < > & b);
+	static void printCompare(const grammar::RightLG < > & a, const grammar::RightLG < > & b);
 	static bool testCompare(const grammar::RightRG& a, const grammar::RightRG& b);
 	static void printCompare(const grammar::RightRG& a, const grammar::RightRG& b);
@@ -65,7 +65,7 @@ private:
 public:
 	static int compare(const grammar::LeftLG < > & a, const grammar::LeftLG < > & b);
 	static int compare(const grammar::LeftRG < > & a, const grammar::LeftRG < > & b);
-	static int compare(const grammar::RightLG& a, const grammar::RightLG& b);
+	static int compare(const grammar::RightLG < > & a, const grammar::RightLG < > & b);
 	static int compare(const grammar::RightRG& a, const grammar::RightRG& b);
 	static int compare(const grammar::LG < > & a, const grammar::LG < > & b);
 	static int compare(const grammar::CFG < > & a, const grammar::CFG < > & b);

alib2algo/src/grammar/parsing/First.cpp

@@ -111,7 +111,7 @@ auto FirstCNF = FirstBase1::RegistratorWrapper < FirstResult1, grammar::CNF < >
 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 FirstRightLG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightLG < > > ( First::first );
 auto FirstRightRG = FirstBase1::RegistratorWrapper < FirstResult1, grammar::RightRG > ( First::first );
 std::map < std::vector < alphabet::Symbol >, std::set < std::variant < alphabet::Symbol, string::Epsilon < > > > > First::first ( const grammar::Grammar & grammar ) {
@@ -125,7 +125,7 @@ auto FirstCNF2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::CNF < >
 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 FirstRightLG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightLG < > > ( First::first );
 auto FirstRightRG2 = FirstBase2::RegistratorWrapper < FirstResult2, grammar::RightRG > ( First::first );
 std::set < std::variant < alphabet::Symbol, string::Epsilon < > > > First::first ( const grammar::Grammar & grammar, const std::vector < alphabet::Symbol > & rhs ) {

alib2algo/src/grammar/parsing/Follow.cpp

@@ -99,7 +99,7 @@ auto FollowCNF = FollowBase1::RegistratorWrapper < FollowResult1, grammar::CNF <
 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 FollowRightLG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightLG < > > ( Follow::follow );
 auto FollowRightRG = FollowBase1::RegistratorWrapper < FollowResult1, grammar::RightRG > ( Follow::follow );
 std::map < alphabet::Symbol, std::set < std::variant < alphabet::Symbol, string::Epsilon < > > > > Follow::follow ( const grammar::Grammar & grammar ) {
@@ -113,7 +113,7 @@ auto FollowCNF2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::CNF
 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 FollowRightLG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightLG < > > ( Follow::follow );
 auto FollowRightRG2 = FollowBase2::RegistratorWrapper < FollowResult2, grammar::RightRG > ( Follow::follow );
 std::set < std::variant < alphabet::Symbol, string::Epsilon < > > > Follow::follow ( const grammar::Grammar & grammar, const alphabet::Symbol & nt ) {

alib2algo/src/grammar/parsing/LL1ParseTable.cpp

@@ -57,7 +57,7 @@ auto LL1ParseTableCNF = LL1ParseTable::RegistratorWrapper < std::map < std::pair
 auto LL1ParseTableLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LG < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableLeftLG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LeftLG < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableLeftRG  = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::LeftRG < > > ( LL1ParseTable::parseTable );
-auto LL1ParseTableRightLG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::RightLG > ( LL1ParseTable::parseTable );
+auto LL1ParseTableRightLG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::RightLG < > > ( LL1ParseTable::parseTable );
 auto LL1ParseTableRightRG = LL1ParseTable::RegistratorWrapper < std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > >, grammar::RightRG > ( LL1ParseTable::parseTable );
 std::map < std::pair < std::variant < alphabet::Symbol, string::Epsilon < > >, alphabet::Symbol >, std::set < std::vector < alphabet::Symbol > > > LL1ParseTable::parseTable ( const grammar::Grammar & grammar ) {

alib2algo/src/grammar/properties/IsLanguageEmpty.cpp

@@ -35,7 +35,7 @@ auto IsLanguageEmptyCNF = IsLanguageEmpty::RegistratorWrapper<bool, grammar::CNF
 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 IsLanguageEmptyRightLG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightLG < > >(IsLanguageEmpty::isLanguageEmpty);
 auto IsLanguageEmptyRightRG = IsLanguageEmpty::RegistratorWrapper<bool, grammar::RightRG>(IsLanguageEmpty::isLanguageEmpty);
 } /* namespace properties */

alib2algo/src/grammar/properties/IsLanguageGeneratingEpsilon.cpp

@@ -35,7 +35,7 @@ auto IsLanguageGeneratingEpsilonCNF = IsLanguageGeneratingEpsilon::RegistratorWr
 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 IsLanguageGeneratingEpsilonRightLG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightLG < > >(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 auto IsLanguageGeneratingEpsilonRightRG = IsLanguageGeneratingEpsilon::RegistratorWrapper<bool, grammar::RightRG>(IsLanguageGeneratingEpsilon::isLanguageGeneratingEpsilon);
 } /* namespace properties */

alib2algo/src/grammar/properties/NonterminalUnitRuleCycle.cpp

@@ -64,7 +64,7 @@ auto NonterminalUnitRuleCycleCNF = NonterminalUnitRuleCycle::RegistratorWrapper<
 auto NonterminalUnitRuleCycleLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleLeftLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleLeftRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
-auto NonterminalUnitRuleCycleRightLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
+auto NonterminalUnitRuleCycleRightLG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG < > >(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 auto NonterminalUnitRuleCycleRightRG = NonterminalUnitRuleCycle::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle);
 std::set<alphabet::Symbol> NonterminalUnitRuleCycle::getNonterminalUnitRuleCycle(const grammar::Grammar& grammar, const alphabet::Symbol& nonterminal) {

alib2algo/src/grammar/properties/NullableNonterminals.cpp

@@ -58,7 +58,7 @@ auto NullableNonterminalsCNF = NullableNonterminals::RegistratorWrapper<std::set
 auto NullableNonterminalsLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsLeftLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsLeftRG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG < > >(NullableNonterminals::getNullableNonterminals);
-auto NullableNonterminalsRightLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(NullableNonterminals::getNullableNonterminals);
+auto NullableNonterminalsRightLG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG < > >(NullableNonterminals::getNullableNonterminals);
 auto NullableNonterminalsRightRG = NullableNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(NullableNonterminals::getNullableNonterminals);
 } /* namespace properties */

alib2algo/src/grammar/properties/ProductiveNonterminals.cpp

@@ -63,7 +63,7 @@ auto ProductiveNonterminalsCNF = ProductiveNonterminals::RegistratorWrapper<std:
 auto ProductiveNonterminalsLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsLeftLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsLeftRG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG < > >(ProductiveNonterminals::getProductiveNonterminals);
-auto ProductiveNonterminalsRightLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(ProductiveNonterminals::getProductiveNonterminals);
+auto ProductiveNonterminalsRightLG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG < > >(ProductiveNonterminals::getProductiveNonterminals);
 auto ProductiveNonterminalsRightRG = ProductiveNonterminals::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(ProductiveNonterminals::getProductiveNonterminals);
 } /* namespace properties */

alib2algo/src/grammar/properties/RecursiveNonterminal.cpp

@@ -70,7 +70,7 @@ auto RecursiveNonterminalCNF = RecursiveNonterminal::RegistratorWrapper < bool,
 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 RecursiveNonterminalRightLG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightLG < > > ( RecursiveNonterminal::isNonterminalRecursive );
 auto RecursiveNonterminalRightRG = RecursiveNonterminal::RegistratorWrapper < bool, grammar::RightRG > ( RecursiveNonterminal::isNonterminalRecursive );
 bool RecursiveNonterminal::isNonterminalRecursive ( const grammar::Grammar & grammar, const alphabet::Symbol & nonterminal ) {

alib2algo/src/grammar/properties/UnreachableSymbols.cpp

@@ -64,7 +64,7 @@ auto UnreachableSymbolsCNF = UnreachableSymbols::RegistratorWrapper<std::set<alp
 auto UnreachableSymbolsLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LG < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsLeftLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftLG < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsLeftRG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::LeftRG < > >(UnreachableSymbols::getUnreachableSymbols);
-auto UnreachableSymbolsRightLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG>(UnreachableSymbols::getUnreachableSymbols);
+auto UnreachableSymbolsRightLG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightLG < > >(UnreachableSymbols::getUnreachableSymbols);
 auto UnreachableSymbolsRightRG = UnreachableSymbols::RegistratorWrapper<std::set<alphabet::Symbol>, grammar::RightRG>(UnreachableSymbols::getUnreachableSymbols);
 } /* namespace properties */

alib2algo/src/grammar/simplify/EpsilonRemover.cpp

@@ -94,11 +94,11 @@ grammar::LeftRG < > EpsilonRemover::remove(const grammar::LeftRG < > & origGramm
 auto EpsilonRemoverLeftRG = EpsilonRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(EpsilonRemover::remove);
-grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::RightLG& origGrammar) {
+grammar::EpsilonFreeCFG < > EpsilonRemover::remove(const grammar::RightLG < > & origGrammar) {
 	return removeInternal(origGrammar);
 }
-auto EpsilonRemoverRightLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::RightLG>(EpsilonRemover::remove);
+auto EpsilonRemoverRightLG = EpsilonRemover::RegistratorWrapper<grammar::EpsilonFreeCFG < >, grammar::RightLG < > >(EpsilonRemover::remove);
 grammar::RightRG EpsilonRemover::remove(const grammar::RightRG& origGrammar) {
 	return origGrammar;

alib2algo/src/grammar/simplify/EpsilonRemover.h

@@ -39,7 +39,7 @@ public:
 	static grammar::EpsilonFreeCFG < > remove( const grammar::LG < > & grammar );
 	static grammar::EpsilonFreeCFG < > remove( const grammar::LeftLG < > & grammar );
 	static grammar::LeftRG < > remove( const grammar::LeftRG < > & grammar );
-	static grammar::EpsilonFreeCFG < > remove( const grammar::RightLG & grammar );
+	static grammar::EpsilonFreeCFG < > remove( const grammar::RightLG < > & grammar );
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
 };

alib2algo/src/grammar/simplify/LeftRecursionRemover.cpp

@@ -160,11 +160,11 @@ grammar::RightRG LeftRecursionRemover::remove(const grammar::RightRG& origGramma
 auto LeftRecursionRemoverRightRG = LeftRecursionRemover::RegistratorWrapper<grammar::RightRG, grammar::RightRG>(LeftRecursionRemover::remove);
-grammar::RightLG LeftRecursionRemover::remove(const grammar::RightLG& origGrammar) {
+grammar::RightLG < > LeftRecursionRemover::remove(const grammar::RightLG < > & origGrammar) {
 	return origGrammar;
 }
-auto LeftRecursionRemoverRightLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG, grammar::RightLG>(LeftRecursionRemover::remove);
+auto LeftRecursionRemoverRightLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(LeftRecursionRemover::remove);
 grammar::RightRG LeftRecursionRemover::remove(const grammar::LeftRG < > & origGrammar) {
 	return convert::ToGrammarRightRG::convert(origGrammar);
@@ -172,11 +172,11 @@ grammar::RightRG LeftRecursionRemover::remove(const grammar::LeftRG < > & origGr
 auto LeftRecursionRemoverLeftRG = LeftRecursionRemover::RegistratorWrapper<grammar::RightRG, grammar::LeftRG < > >(LeftRecursionRemover::remove);
-grammar::RightLG LeftRecursionRemover::remove(const grammar::LeftLG < > & /* origGrammar */) {
+grammar::RightLG < > LeftRecursionRemover::remove(const grammar::LeftLG < > & /* origGrammar */) {
 	throw exception::CommonException("LeftRecursionRemover: Removing from LeftLG NYI"); // TODO
 }
-auto LeftRecursionRemoverLeftLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG, grammar::LeftLG < > >(LeftRecursionRemover::remove);
+auto LeftRecursionRemoverLeftLG = LeftRecursionRemover::RegistratorWrapper<grammar::RightLG < >, grammar::LeftLG < > >(LeftRecursionRemover::remove);
 grammar::Grammar LeftRecursionRemover::remove(const grammar::Grammar& grammar) {
 	return dispatch(grammar.getData());

alib2algo/src/grammar/simplify/LeftRecursionRemover.h

@@ -36,9 +36,9 @@ public:
 	static grammar::EpsilonFreeCFG < > remove( const grammar::CNF < > & grammar );
 	static grammar::GNF < > remove( const grammar::GNF < > & grammar );
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
-	static grammar::RightLG remove( const grammar::RightLG & grammar );
+	static grammar::RightLG < > remove( const grammar::RightLG < > & grammar );
 	static grammar::RightRG remove( const grammar::LeftRG < > & grammar );
-	static grammar::RightLG remove( const grammar::LeftLG < > & grammar );
+	static grammar::RightLG < > remove( const grammar::LeftLG < > & grammar );
 };
 } /* namespace simplify */

alib2algo/src/grammar/simplify/SimpleRulesRemover.cpp

@@ -109,11 +109,11 @@ grammar::LeftRG < > SimpleRulesRemover::remove(const grammar::LeftRG < > & origG
 auto SimpleRulesRemoverLeftRG = SimpleRulesRemover::RegistratorWrapper<grammar::LeftRG < >, grammar::LeftRG < > >(SimpleRulesRemover::remove);
-grammar::RightLG SimpleRulesRemover::remove(const grammar::RightLG& origGrammar) {
+grammar::RightLG < > SimpleRulesRemover::remove(const grammar::RightLG < > & origGrammar) {
 	return removeNonEpsilonFree(origGrammar);
 }
-auto SimpleRulesRemoverRightLG = SimpleRulesRemover::RegistratorWrapper<grammar::RightLG, grammar::RightLG>(SimpleRulesRemover::remove);
+auto SimpleRulesRemoverRightLG = SimpleRulesRemover::RegistratorWrapper<grammar::RightLG < >, grammar::RightLG < > >(SimpleRulesRemover::remove);
 grammar::RightRG SimpleRulesRemover::remove(const grammar::RightRG& origGrammar) {
 	return origGrammar;

alib2algo/src/grammar/simplify/SimpleRulesRemover.h

@@ -39,7 +39,7 @@ public:
 	static grammar::LG < > remove( const grammar::LG < > & grammar );
 	static grammar::LeftLG < > remove( const grammar::LeftLG < > & grammar );
 	static grammar::LeftRG < > remove( const grammar::LeftRG < > & grammar );
-	static grammar::RightLG remove( const grammar::RightLG & grammar );
+	static grammar::RightLG < > remove( const grammar::RightLG < > & grammar );
 	static grammar::RightRG remove( const grammar::RightRG & grammar );
 };