From 0e0b2892c692c903d0e8e9283ceb2f4997dc2169 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Pecka?= <peckato1@fit.cvut.cz>
Date: Fri, 19 Sep 2014 20:33:10 +0200
Subject: [PATCH] algo: rg2rg api
---
aconversions2/src/ConversionHandler.cpp | 10 +-
.../rg2rg/LeftToRightRegularGrammar.cpp | 149 +++++++++++++++++
.../rg2rg/LeftToRightRegularGrammar.h | 61 +++++++
.../rg2rg/RightToLeftRegularGrammar.cpp | 152 ++++++++++++++++++
.../rg2rg/RightToLeftRegularGrammar.h | 62 +++++++
.../lrg2rrg/LeftToRightRegularGrammar.cpp | 65 --------
.../rg2rg/lrg2rrg/LeftToRightRegularGrammar.h | 33 ----
.../rrg2lrg/RightToLeftRegularGrammar.cpp | 67 --------
.../rg2rg/rrg2lrg/RightToLeftRegularGrammar.h | 37 -----
.../test-src/conversions/rg2rg/rg2rgTest.cpp | 10 +-
10 files changed, 432 insertions(+), 214 deletions(-)
create mode 100644 alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.cpp
create mode 100644 alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.h
create mode 100644 alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.cpp
create mode 100644 alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.h
delete mode 100644 alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
delete mode 100644 alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
delete mode 100644 alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
delete mode 100644 alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 6d56b8ed25..dec0494d0b 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -25,8 +25,8 @@
#include "conversions/re2rg/re2rrg/GlushkovNFA.h"
#include "conversions/re2rg/re2rrg/BrzozowskiDerivation.h"
-#include "conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h"
-#include "conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h"
+#include "conversions/rg2rg/LeftToRightRegularGrammar.h"
+#include "conversions/rg2rg/RightToLeftRegularGrammar.h"
using namespace alib;
@@ -288,8 +288,7 @@ void ConversionHandler::convertLRGtoRRG( void )
switch( m_algorithm )
{
default:
- conversions::rg2rg::LeftToRightRegularGrammar conv;
- alib::DataFactory::toStdout(conv.convert(lrg));
+ alib::DataFactory::toStdout(conversions::rg2rg::LeftToRightRegularGrammar::convert(lrg));
break;
}
}
@@ -301,8 +300,7 @@ void ConversionHandler::convertRRGtoLRG( void )
switch( m_algorithm )
{
default:
- conversions::rg2rg::RightToLeftRegularGrammar conv;
- alib::DataFactory::toStdout(conv.convert(rrg));
+ alib::DataFactory::toStdout(conversions::rg2rg::RightToLeftRegularGrammar::convert(rrg));
break;
}
}
diff --git a/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.cpp b/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.cpp
new file mode 100644
index 0000000000..ab6089d162
--- /dev/null
+++ b/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.cpp
@@ -0,0 +1,149 @@
+/*
+ * LeftToRightRegularGrammar.cpp
+ *
+ * Created on: 8. 3. 2014
+ * Author: Tomas Pecka
+ */
+
+#include "LeftToRightRegularGrammar.h"
+
+#include <exception/AlibException.h>
+
+namespace conversions {
+
+namespace rg2rg {
+
+grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::Grammar& grammar)
+{
+ grammar::RightRG* out = NULL;
+ grammar.getData().Accept((void*) &out, LeftToRightRegularGrammar::LEFT_TO_RIGHT_REGULAR_GRAMMAR);
+ grammar::RightRG res = std::move(*out);
+ delete out;
+ return res;
+}
+
+grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::LeftRG& grammar)
+{
+ // 1.
+ alphabet::Symbol s = alphabet::createUniqueSymbol( grammar.getInitialSymbol( ), grammar.getNonterminalAlphabet(), grammar.getTerminalAlphabet() );
+
+ grammar::RightRG rrg( s );
+
+ for(const auto & nonterminalSymbol : grammar.getNonterminalAlphabet() ) {
+ rrg.addNonterminalSymbol( nonterminalSymbol );
+ }
+
+ rrg.setTerminalAlphabet( grammar.getTerminalAlphabet( ) );
+ rrg.setGeneratesEpsilon( grammar.getGeneratesEpsilon( ) );
+
+ // 2
+ for( const auto & rule : grammar.getRules( ) ) {
+ const alphabet::Symbol& lhs = rule.first;
+
+ for(const auto & ruleRHS : rule.second ) {
+ if( ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>( ) ) {
+ const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
+
+ alphabet::Symbol leftSide = ( rhs.first );
+ std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( rhs.second, lhs );
+ rrg.addRule( leftSide, rightSide );
+
+ if( lhs == grammar.getInitialSymbol( ) ) {
+ alphabet::Symbol leftSide = rhs.first;
+ alphabet::Symbol rightSide = rhs.second;
+ rrg.addRule( leftSide, rightSide );
+ }
+ } else {
+ const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
+
+ alphabet::Symbol leftSide = rrg.getInitialSymbol( );
+ std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( rhs, lhs );
+ rrg.addRule( leftSide, rightSide );
+
+ if( lhs == grammar.getInitialSymbol( ) ) {
+ alphabet::Symbol leftSide = rrg.getInitialSymbol( );
+ alphabet::Symbol rightSide = rhs;
+ rrg.addRule( leftSide, rightSide );
+ }
+ }
+ }
+ }
+ return rrg;
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::UnknownGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type UnknownGrammar");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type ContextPreservingUnrestrictedGrammar");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::UnrestrictedGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type UnrestrictedGrammar");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::CSG&) const
+{
+ throw exception::AlibException("Unsupported grammar type CSG");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::NonContractingGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type NonContractingGrammar");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::CNF&) const
+{
+ throw exception::AlibException("Unsupported grammar type CNF");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::CFG&) const
+{
+ throw exception::AlibException("Unsupported grammar type CFG");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::EpsilonFreeCFG&) const
+{
+ throw exception::AlibException("Unsupported grammar type EpsilonFreeCFG");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::GNF&) const
+{
+ throw exception::AlibException("Unsupported grammar type GNF");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::LG&) const
+{
+ throw exception::AlibException("Unsupported grammar type LG");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::RightRG&) const
+{
+ throw exception::AlibException("Unsupported grammar type RightRG");
+}
+
+void LeftToRightRegularGrammar::Visit(void* userData, const grammar::LeftRG& grammar) const
+{
+ grammar::RightRG* & out = *((grammar::RightRG**) userData);
+ out = new grammar::RightRG(this->convert(grammar));
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::RightLG&) const
+{
+ throw exception::AlibException("Unsupported grammar type RightLG");
+}
+
+void LeftToRightRegularGrammar::Visit(void*, const grammar::LeftLG&) const
+{
+ throw exception::AlibException("Unsupported grammar type LeftLG");
+}
+
+const LeftToRightRegularGrammar LeftToRightRegularGrammar::LEFT_TO_RIGHT_REGULAR_GRAMMAR;
+
+} /* namespace rg2rg */
+
+} /* namespace conversions */
diff --git a/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.h b/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.h
new file mode 100644
index 0000000000..ab25664de2
--- /dev/null
+++ b/alib2algo/src/conversions/rg2rg/LeftToRightRegularGrammar.h
@@ -0,0 +1,61 @@
+/*
+ * LeftToRightRegularGrammar.h
+ *
+ * Created on: 8. 3. 2014
+ * Author: Tomas Pecka
+ */
+
+#ifndef LEFT_TORIGHT_REGULAR_GRAMMAR_H_
+#define LEFT_TORIGHT_REGULAR_GRAMMAR_H_
+
+#include <grammar/Grammar.h>
+#include <grammar/Regular/LeftRG.h>
+#include <grammar/Regular/RightRG.h>
+
+namespace conversions{
+
+namespace rg2rg
+{
+
+/**
+ * Converts left regular grammar to right regular grammar.
+ */
+class LeftToRightRegularGrammar : public grammar::VisitableGrammarBase::const_visitor_type
+{
+public:
+ /**
+ * Performs conversion.
+ * @param grammar Left regular grammar to convert
+ * @return right regular grammar which is equivalent to source left regular grammar.
+ */
+ static grammar::RightRG convert(const grammar::Grammar& grammar);
+ static grammar::RightRG convert(const grammar::LeftRG& grammar);
+
+private:
+ void Visit(void*, const grammar::UnknownGrammar& grammar) const;
+
+ void Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar& grammar) const;
+ void Visit(void*, const grammar::UnrestrictedGrammar& grammar) const;
+
+ void Visit(void*, const grammar::CSG& grammar) const;
+ void Visit(void*, const grammar::NonContractingGrammar& grammar) const;
+
+ void Visit(void*, const grammar::CNF& grammar) const;
+ void Visit(void*, const grammar::CFG& grammar) const;
+ void Visit(void*, const grammar::EpsilonFreeCFG& grammar) const;
+ void Visit(void*, const grammar::GNF& grammar) const;
+ void Visit(void*, const grammar::LG& grammar) const;
+
+ void Visit(void*, const grammar::RightRG& grammar) const;
+ void Visit(void*, const grammar::LeftRG& grammar) const;
+ void Visit(void*, const grammar::RightLG& grammar) const;
+ void Visit(void*, const grammar::LeftLG& grammar) const;
+
+ static const LeftToRightRegularGrammar LEFT_TO_RIGHT_REGULAR_GRAMMAR;
+};
+
+} /* namespace rg2rg */
+
+} /* namespace conversions */
+
+#endif /* LEFT_TO_RIGHT_REGULAR_GRAMMAR_H_ */
diff --git a/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.cpp b/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.cpp
new file mode 100644
index 0000000000..d1da71429b
--- /dev/null
+++ b/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.cpp
@@ -0,0 +1,152 @@
+/*
+ * RightToLeftRegularGrammar.cpp
+ *
+ * Created on: 8. 3. 2014
+ * Author: Tomas Pecka
+ */
+
+#include "RightToLeftRegularGrammar.h"
+
+#include <exception/AlibException.h>
+
+namespace conversions
+{
+
+namespace rg2rg
+{
+
+grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::Grammar& grammar)
+{
+ grammar::LeftRG* out = NULL;
+ grammar.getData().Accept((void*) &out, RightToLeftRegularGrammar::RIGHT_TO_LEFT_REGULAR_GRAMMAR);
+ grammar::LeftRG res = std::move(*out);
+ delete out;
+ return res;
+}
+
+grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::RightRG& grammar)
+{
+ // 1.
+ alphabet::Symbol s = alphabet::createUniqueSymbol( grammar.getInitialSymbol( ), grammar.getNonterminalAlphabet(), grammar.getTerminalAlphabet() );
+
+ grammar::LeftRG lrg(s);
+
+ for(const auto & nonterminalSymbol : grammar.getNonterminalAlphabet()) {
+ lrg.addNonterminalSymbol( nonterminalSymbol );
+ }
+
+ lrg.setTerminalAlphabet( grammar.getTerminalAlphabet( ) );
+ lrg.setGeneratesEpsilon( grammar.getGeneratesEpsilon( ) );
+
+ // 2.
+ for( const auto & rule : grammar.getRules( ) ) {
+ const alphabet::Symbol& lhs = rule.first;
+
+ for(const auto & ruleRHS : rule.second ) {
+ if( ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>( ) ) {
+ const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
+
+ alphabet::Symbol leftSide = rhs.second;
+ std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( lhs, rhs.first );
+ lrg.addRule( leftSide, rightSide );
+
+ if( lhs == grammar.getInitialSymbol( ) ) {
+ alphabet::Symbol leftSide = rhs.second;
+ alphabet::Symbol rightSide = rhs.first;
+ lrg.addRule( leftSide, rightSide );
+ }
+ } else {
+ const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
+
+ alphabet::Symbol leftSide = lrg.getInitialSymbol( );
+ std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair ( lhs, rhs );
+ lrg.addRule( leftSide, rightSide );
+
+ if( lhs == grammar.getInitialSymbol( ) ) {
+ alphabet::Symbol leftSide = lrg.getInitialSymbol( );
+ alphabet::Symbol rightSide = rhs;
+ lrg.addRule( leftSide, rightSide );
+ }
+ }
+ }
+ }
+ return lrg;
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::UnknownGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type UnknownGrammar");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type ContextPreservingUnrestrictedGrammar");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::UnrestrictedGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type UnrestrictedGrammar");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::CSG&) const
+{
+ throw exception::AlibException("Unsupported grammar type CSG");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::NonContractingGrammar&) const
+{
+ throw exception::AlibException("Unsupported grammar type NonContractingGrammar");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::CNF&) const
+{
+ throw exception::AlibException("Unsupported grammar type CNF");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::CFG&) const
+{
+ throw exception::AlibException("Unsupported grammar type CFG");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::EpsilonFreeCFG&) const
+{
+ throw exception::AlibException("Unsupported grammar type EpsilonFreeCFG");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::GNF&) const
+{
+ throw exception::AlibException("Unsupported grammar type GNF");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::LG&) const
+{
+ throw exception::AlibException("Unsupported grammar type LG");
+}
+
+void RightToLeftRegularGrammar::Visit(void* userData, const grammar::RightRG& grammar) const
+{
+ grammar::LeftRG* & out = *((grammar::LeftRG**) userData);
+ out = new grammar::LeftRG(this->convert(grammar));
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::LeftRG&) const
+{
+ throw exception::AlibException("Unsupported grammar type RightRG");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::RightLG&) const
+{
+ throw exception::AlibException("Unsupported grammar type RightLG");
+}
+
+void RightToLeftRegularGrammar::Visit(void*, const grammar::LeftLG&) const
+{
+ throw exception::AlibException("Unsupported grammar type LeftLG");
+}
+
+const RightToLeftRegularGrammar RightToLeftRegularGrammar::RIGHT_TO_LEFT_REGULAR_GRAMMAR;
+
+
+} /* namespace rg2rg */
+
+} /* namespace conversions */
diff --git a/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.h b/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.h
new file mode 100644
index 0000000000..bccd75f130
--- /dev/null
+++ b/alib2algo/src/conversions/rg2rg/RightToLeftRegularGrammar.h
@@ -0,0 +1,62 @@
+/*
+ * RightToLeftRegularGrammar.h
+ *
+ * Created on: 8. 3. 2014
+ * Author: Tomas Pecka
+ */
+
+#ifndef RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
+#define RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
+
+#include <grammar/Grammar.h>
+#include <grammar/Regular/LeftRG.h>
+#include <grammar/Regular/RightRG.h>
+
+namespace conversions
+{
+
+namespace rg2rg
+{
+
+/**
+ * Converts right regular grammar to left regular grammar.
+ */
+class RightToLeftRegularGrammar : public grammar::VisitableGrammarBase::const_visitor_type
+{
+public:
+ /**
+ * Performs conversion.
+ * @param grammar Right regular grammar to convert
+ * @return left regular grammar which is equivalent to source right regular grammar.
+ */
+ static grammar::LeftRG convert(const grammar::Grammar& grammar);
+ static grammar::LeftRG convert(const grammar::RightRG& grammar);
+
+private:
+ void Visit(void*, const grammar::UnknownGrammar& grammar) const;
+
+ void Visit(void*, const grammar::ContextPreservingUnrestrictedGrammar& grammar) const;
+ void Visit(void*, const grammar::UnrestrictedGrammar& grammar) const;
+
+ void Visit(void*, const grammar::CSG& grammar) const;
+ void Visit(void*, const grammar::NonContractingGrammar& grammar) const;
+
+ void Visit(void*, const grammar::CNF& grammar) const;
+ void Visit(void*, const grammar::CFG& grammar) const;
+ void Visit(void*, const grammar::EpsilonFreeCFG& grammar) const;
+ void Visit(void*, const grammar::GNF& grammar) const;
+ void Visit(void*, const grammar::LG& grammar) const;
+
+ void Visit(void*, const grammar::RightRG& grammar) const;
+ void Visit(void*, const grammar::LeftRG& grammar) const;
+ void Visit(void*, const grammar::RightLG& grammar) const;
+ void Visit(void*, const grammar::LeftLG& grammar) const;
+
+ static const RightToLeftRegularGrammar RIGHT_TO_LEFT_REGULAR_GRAMMAR;
+};
+
+} /* namespace rg2rg */
+
+} /* namespace conversions */
+
+#endif /* RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_ */
diff --git a/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp b/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
deleted file mode 100644
index 0a1cca7dba..0000000000
--- a/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * LeftToRightRegularGrammar.cpp
- *
- * Created on: 8. 3. 2014
- * Author: Tomas Pecka
- */
-
-#include "LeftToRightRegularGrammar.h"
-
-namespace conversions {
-
-namespace rg2rg {
-
-grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::LeftRG& lrg)
-{
- // 1.
- alphabet::Symbol s = alphabet::createUniqueSymbol( lrg.getInitialSymbol( ), lrg.getNonterminalAlphabet(), lrg.getTerminalAlphabet() );
-
- grammar::RightRG rrg( s );
-
- for(const auto & nonterminalSymbol : lrg.getNonterminalAlphabet() ) {
- rrg.addNonterminalSymbol( nonterminalSymbol );
- }
-
- rrg.setTerminalAlphabet( lrg.getTerminalAlphabet( ) );
- rrg.setGeneratesEpsilon( lrg.getGeneratesEpsilon( ) );
-
- // 2
- for( const auto & rule : lrg.getRules( ) ) {
- const alphabet::Symbol& lhs = rule.first;
-
- for(const auto & ruleRHS : rule.second ) {
- if( ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>( ) ) {
- const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
-
- alphabet::Symbol leftSide = ( rhs.first );
- std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( rhs.second, lhs );
- rrg.addRule( leftSide, rightSide );
-
- if( lhs == lrg.getInitialSymbol( ) ) {
- alphabet::Symbol leftSide = rhs.first;
- alphabet::Symbol rightSide = rhs.second;
- rrg.addRule( leftSide, rightSide );
- }
- } else {
- const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
-
- alphabet::Symbol leftSide = rrg.getInitialSymbol( );
- std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( rhs, lhs );
- rrg.addRule( leftSide, rightSide );
-
- if( lhs == lrg.getInitialSymbol( ) ) {
- alphabet::Symbol leftSide = rrg.getInitialSymbol( );
- alphabet::Symbol rightSide = rhs;
- rrg.addRule( leftSide, rightSide );
- }
- }
- }
- }
- return rrg;
-}
-
-} /* namespace rg2rg */
-
-} /* namespace conversions */
diff --git a/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h b/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
deleted file mode 100644
index b217f73568..0000000000
--- a/alib2algo/src/conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * LeftToRightRegularGrammar.h
- *
- * Created on: 8. 3. 2014
- * Author: Tomas Pecka
- */
-
-#ifndef LEFT_TORIGHT_REGULAR_GRAMMAR_H_
-#define LEFT_TORIGHT_REGULAR_GRAMMAR_H_
-
-#include <grammar/Regular/LeftRG.h>
-#include <grammar/Regular/RightRG.h>
-
-namespace conversions{
-
-namespace rg2rg
-{
-
-class LeftToRightRegularGrammar
-{
-public:
- /**
- * Performs conversion.
- * @return right regular grammar which is equivalent to source left regular grammar.
- */
- grammar::RightRG convert(const grammar::LeftRG& lrg);
-};
-
-} /* namespace rg2rg */
-
-} /* namespace conversions */
-
-#endif /* LEFT_TO_RIGHT_REGULAR_GRAMMAR_H_ */
diff --git a/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp b/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
deleted file mode 100644
index a43a808f34..0000000000
--- a/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * RightToLeftRegularGrammar.cpp
- *
- * Created on: 8. 3. 2014
- * Author: Tomas Pecka
- */
-
-#include "RightToLeftRegularGrammar.h"
-
-namespace conversions
-{
-
-namespace rg2rg
-{
-
-grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::RightRG& rrg)
-{
- // 1.
- alphabet::Symbol s = alphabet::createUniqueSymbol( rrg.getInitialSymbol( ), rrg.getNonterminalAlphabet(), rrg.getTerminalAlphabet() );
-
- grammar::LeftRG lrg(s);
-
- for(const auto & nonterminalSymbol : rrg.getNonterminalAlphabet()) {
- lrg.addNonterminalSymbol( nonterminalSymbol );
- }
-
- lrg.setTerminalAlphabet( rrg.getTerminalAlphabet( ) );
- lrg.setGeneratesEpsilon( rrg.getGeneratesEpsilon( ) );
-
- // 2.
- for( const auto & rule : rrg.getRules( ) ) {
- const alphabet::Symbol& lhs = rule.first;
-
- for(const auto & ruleRHS : rule.second ) {
- if( ruleRHS.is<std::pair<alphabet::Symbol, alphabet::Symbol>>( ) ) {
- const std::pair<alphabet::Symbol, alphabet::Symbol>& rhs = ruleRHS.get<std::pair<alphabet::Symbol, alphabet::Symbol>>();
-
- alphabet::Symbol leftSide = rhs.second;
- std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair( lhs, rhs.first );
- lrg.addRule( leftSide, rightSide );
-
- if( lhs == rrg.getInitialSymbol( ) ) {
- alphabet::Symbol leftSide = rhs.second;
- alphabet::Symbol rightSide = rhs.first;
- lrg.addRule( leftSide, rightSide );
- }
- } else {
- const alphabet::Symbol& rhs = ruleRHS.get<alphabet::Symbol>();
-
- alphabet::Symbol leftSide = lrg.getInitialSymbol( );
- std::pair<alphabet::Symbol, alphabet::Symbol> rightSide = std::make_pair ( lhs, rhs );
- lrg.addRule( leftSide, rightSide );
-
- if( lhs == rrg.getInitialSymbol( ) ) {
- alphabet::Symbol leftSide = lrg.getInitialSymbol( );
- alphabet::Symbol rightSide = rhs;
- lrg.addRule( leftSide, rightSide );
- }
- }
- }
- }
- return lrg;
-}
-
-} /* namespace rg2rg */
-
-} /* namespace conversions */
diff --git a/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h b/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
deleted file mode 100644
index 7cecd00f27..0000000000
--- a/alib2algo/src/conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * RightToLeftRegularGrammar.h
- *
- * Created on: 8. 3. 2014
- * Author: Tomas Pecka
- */
-
-#ifndef RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
-#define RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
-
-#include <grammar/Regular/LeftRG.h>
-#include <grammar/Regular/RightRG.h>
-
-namespace conversions
-{
-
-namespace rg2rg
-{
-
-/**
- * Converts right regular grammar to left regular grammar.
- */
-class RightToLeftRegularGrammar
-{
-public:
- /**
- * Performs conversion.
- * @return left regular grammar which is equivalent to source right regular grammar.
- */
- grammar::LeftRG convert(const grammar::RightRG& rrg);
-};
-
-} /* namespace rg2rg */
-
-} /* namespace conversions */
-
-#endif /* RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_ */
diff --git a/alib2algo/test-src/conversions/rg2rg/rg2rgTest.cpp b/alib2algo/test-src/conversions/rg2rg/rg2rgTest.cpp
index c8952a6718..8f1862e70d 100644
--- a/alib2algo/test-src/conversions/rg2rg/rg2rgTest.cpp
+++ b/alib2algo/test-src/conversions/rg2rg/rg2rgTest.cpp
@@ -6,8 +6,8 @@
#include "label/Label.h"
#include "alphabet/LabeledSymbol.h"
-#include "conversions/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h"
-#include "conversions/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h"
+#include "conversions/rg2rg/RightToLeftRegularGrammar.h"
+#include "conversions/rg2rg/LeftToRightRegularGrammar.h"
#define CPPUNIT_IMPLY(x, y) CPPUNIT_ASSERT(!(x) || (y))
@@ -32,8 +32,7 @@ void rg2rgTest::testConversion() {
rrGrammar.addRule(alphabet::symbolFrom(2), std::make_pair(alphabet::symbolFrom("b"), alphabet::symbolFrom(3)));
rrGrammar.addRule(alphabet::symbolFrom(3), alphabet::symbolFrom("a"));
- conversions::rg2rg::RightToLeftRegularGrammar convertor;;
- grammar::LeftRG lrGrammar = convertor.convert(rrGrammar);
+ grammar::LeftRG lrGrammar = conversions::rg2rg::RightToLeftRegularGrammar::convert(rrGrammar);
grammar::LeftRG lrGrammarRef(alphabet::symbolFrom(4));
@@ -64,8 +63,7 @@ void rg2rgTest::testConversion2() {
lrGrammar.addRule(alphabet::symbolFrom(3), std::make_pair(alphabet::symbolFrom(2), alphabet::symbolFrom("b")));
lrGrammar.addRule(alphabet::symbolFrom(4), std::make_pair(alphabet::symbolFrom(3), alphabet::symbolFrom("a")));
- conversions::rg2rg::LeftToRightRegularGrammar convertor;
- grammar::RightRG rrGrammar = convertor.convert(lrGrammar);
+ grammar::RightRG rrGrammar = conversions::rg2rg::LeftToRightRegularGrammar::convert(lrGrammar);
grammar::RightRG rrGrammarRef(alphabet::Symbol(alphabet::LabeledSymbol(label::Label(label::IntegerLabel(5)))));
--
GitLab