diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 064a18fa3f840e7ad55b4874107b507f5bee1029..99955d0f316c62077b76c6e3c9623520b97b8a31 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -9,22 +9,22 @@
#include "automaton/convert/ToRegExpStateElimination.h"
#include "automaton/convert/ToRegExpAlgebraic.h"
-#include "automaton/convert/ToLeftRG.h"
-#include "automaton/convert/ToRightRG.h"
+#include "automaton/convert/ToGrammarLeftRG.h"
+#include "automaton/convert/ToGrammarRightRG.h"
-#include "regexp/toAutomaton/GlushkovNFA.h"
-#include "regexp/toAutomaton/Thompson.h"
-#include "regexp/toAutomaton/BrzozowskiDerivation.h"
+#include "regexp/convert/ToAutomatonGlushkov.h"
+#include "regexp/convert/ToAutomatonThompson.h"
+#include "regexp/convert/ToAutomatonDerivation.h"
-#include "grammar/toAutomaton/RGtoFA.h"
+#include "grammar/convert/ToAutomaton.h"
-#include "grammar/toRegexp/Algebraic.h"
+#include "grammar/convert/ToRegExpAlgebraic.h"
-#include "regexp/toGrammar/toRightRG/GlushkovNFA.h"
-#include "regexp/toGrammar/toRightRG/BrzozowskiDerivation.h"
+#include "regexp/convert/ToGrammarRightRGGlushkov.h"
+#include "regexp/convert/ToGrammarRightRGDerivation.h"
-#include "grammar/toGrammar/LeftToRightRegularGrammar.h"
-#include "grammar/toGrammar/RightToLeftRegularGrammar.h"
+#include "grammar/convert/ToGrammarRightRG.h"
+#include "grammar/convert/ToGrammarLeftRG.h"
using namespace alib;
@@ -142,7 +142,7 @@ void ConversionHandler::convertFSMtoRRG( void )
switch( m_algorithm )
{
default: {
- alib::DataFactory::toStdout(automaton::convert::ToRightRG::convert(fsm));
+ alib::DataFactory::toStdout(automaton::convert::ToGrammarRightRG::convert(fsm));
break;
}
}
@@ -155,7 +155,7 @@ void ConversionHandler::convertFSMtoLRG( void )
switch( m_algorithm )
{
default: {
- alib::DataFactory::toStdout(automaton::convert::ToLeftRG::convert(fsm));
+ alib::DataFactory::toStdout(automaton::convert::ToGrammarLeftRG::convert(fsm));
break;
}
}
@@ -170,16 +170,16 @@ void ConversionHandler::convertREtoFSM( void )
switch( m_algorithm )
{
case BRZOZOWSKI_DERIVATION: {
- alib::DataFactory::toStdout(conversions::re2fa::BrzozowskiDerivation::convert(regexp));
+ alib::DataFactory::toStdout(regexp::convert::ToAutomatonDerivation::convert(regexp));
break;
}
case THOMPSON_NFA: {
- alib::DataFactory::toStdout(conversions::re2fa::Thompson::convert(regexp));
+ alib::DataFactory::toStdout(regexp::convert::ToAutomatonThompson::convert(regexp));
break;
}
case GLUSHKOV_NFA:
default: {
- alib::DataFactory::toStdout(conversions::re2fa::GlushkovNFA::convert(regexp));
+ alib::DataFactory::toStdout(regexp::convert::ToAutomatonGlushkov::convert(regexp));
break;
}
}
@@ -202,11 +202,11 @@ void ConversionHandler::convertREtoRRG( void )
switch(m_algorithm)
{
case BRZOZOWSKI_DERIVATION: {
- alib::DataFactory::toStdout(conversions::re2rg::BrzozowskiDerivation::convert(regexp));
+ alib::DataFactory::toStdout(regexp::convert::ToGrammarRightRGDerivation::convert(regexp));
break;
}
default: {
- alib::DataFactory::toStdout(conversions::re2rg::GlushkovNFA::convert(regexp));
+ alib::DataFactory::toStdout(regexp::convert::ToGrammarRightRGGlushkov::convert(regexp));
break;
}
}
@@ -217,7 +217,7 @@ void ConversionHandler::convertREtoRRG( void )
void ConversionHandler::convertRGtoFSM( void )
{
const grammar::Grammar grammar = alib::DataFactory::fromTokens<grammar::Grammar>(m_tokens);
- alib::DataFactory::toStdout(conversions::rg2fa::RGtoFA::convert(grammar));
+ alib::DataFactory::toStdout(grammar::convert::ToAutomaton::convert(grammar));
}
void ConversionHandler::convertRGtoRG( void )
@@ -242,7 +242,7 @@ void ConversionHandler::convertRGtoRE( void )
{
case BRZOZOWSKI_ALGEBRAIC:
default:
- alib::DataFactory::toStdout(conversions::rg2re::Algebraic::convert(grammar));
+ alib::DataFactory::toStdout(grammar::convert::ToRegExpAlgebraic::convert(grammar));
break;
}
}
@@ -254,7 +254,7 @@ void ConversionHandler::convertLRGtoRRG( void )
switch( m_algorithm )
{
default:
- alib::DataFactory::toStdout(conversions::rg2rg::LeftToRightRegularGrammar::convert(lrg));
+ alib::DataFactory::toStdout(grammar::convert::ToGrammarRightRG::convert(lrg));
break;
}
}
@@ -266,7 +266,7 @@ void ConversionHandler::convertRRGtoLRG( void )
switch( m_algorithm )
{
default:
- alib::DataFactory::toStdout(conversions::rg2rg::RightToLeftRegularGrammar::convert(rrg));
+ alib::DataFactory::toStdout(grammar::convert::ToGrammarLeftRG::convert(rrg));
break;
}
}
diff --git a/alib2algo/src/automaton/convert/ToLeftRG.cpp b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
similarity index 80%
rename from alib2algo/src/automaton/convert/ToLeftRG.cpp
rename to alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
index aa2672d61f70c94433e7bb7705e420c6eeeb3cba..ba2a7336d6550b5879d8203311a3423587331a4c 100644
--- a/alib2algo/src/automaton/convert/ToLeftRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
@@ -1,11 +1,11 @@
/*
- * ToLeftRG.h
+ * ToGrammarLeftRG.h
*
* Created on: 9. 2. 2014
- * Author: Tomas Pecka
+ * Author: ToGrammarmas Pecka
*/
-#include "ToLeftRG.h"
+#include "ToGrammarLeftRG.h"
#include <map>
#include <alphabet/LabeledSymbol.h>
@@ -16,7 +16,7 @@ namespace automaton {
namespace convert {
-grammar::LeftRG ToLeftRG::convert(const automaton::NFA& automaton)
+grammar::LeftRG ToGrammarLeftRG::convert(const automaton::NFA& automaton)
{
std::map<automaton::State, alphabet::Symbol> nonterminalMap;
// step 2
@@ -64,7 +64,7 @@ grammar::LeftRG ToLeftRG::convert(const automaton::NFA& automaton)
return grammar;
}
-grammar::LeftRG ToLeftRG::convert(const automaton::DFA& automaton)
+grammar::LeftRG ToGrammarLeftRG::convert(const automaton::DFA& automaton)
{
std::map<automaton::State, alphabet::Symbol> nonterminalMap;
// step 2
@@ -110,41 +110,41 @@ grammar::LeftRG ToLeftRG::convert(const automaton::DFA& automaton)
return grammar;
}
-grammar::Grammar ToLeftRG::convert(const automaton::Automaton& automaton) {
+grammar::Grammar ToGrammarLeftRG::convert(const automaton::Automaton& automaton) {
grammar::Grammar* out = NULL;
- automaton.getData().Accept((void*) &out, ToLeftRG::TO_LEFT_RG);
+ automaton.getData().Accept((void*) &out, ToGrammarLeftRG::TO_GRAMMAR_LEFT_RG);
grammar::Grammar res = std::move(*out);
delete out;
return res;
}
-void ToLeftRG::Visit(void*, const automaton::EpsilonNFA& ) const {
+void ToGrammarLeftRG::Visit(void*, const automaton::EpsilonNFA& ) const {
throw exception::AlibException("Unsupported automaton type EpsilonNFA");
}
-void ToLeftRG::Visit(void*, const automaton::MultiInitialStateNFA& ) const {
+void ToGrammarLeftRG::Visit(void*, const automaton::MultiInitialStateNFA& ) const {
throw exception::AlibException("Unsupported automaton type MultiInitialStateNFA");
}
-void ToLeftRG::Visit(void* data, const automaton::NFA& automaton) const {
+void ToGrammarLeftRG::Visit(void* data, const automaton::NFA& automaton) const {
grammar::Grammar* & out = *((grammar::Grammar**) data);
out = new grammar::Grammar(this->convert(automaton));
}
-void ToLeftRG::Visit(void* data, const automaton::DFA& automaton) const {
+void ToGrammarLeftRG::Visit(void* data, const automaton::DFA& automaton) const {
grammar::Grammar* & out = *((grammar::Grammar**) data);
out = new grammar::Grammar(this->convert(automaton));
}
-void ToLeftRG::Visit(void*, const automaton::ExtendedNFA& ) const {
+void ToGrammarLeftRG::Visit(void*, const automaton::ExtendedNFA& ) const {
throw exception::AlibException("Unsupported automaton type ExtendedNFA");
}
-void ToLeftRG::Visit(void*, const automaton::CompactNFA& ) const {
+void ToGrammarLeftRG::Visit(void*, const automaton::CompactNFA& ) const {
throw exception::AlibException("Unsupported automaton type CompactNFA");
}
-const ToLeftRG ToLeftRG::TO_LEFT_RG;
+const ToGrammarLeftRG ToGrammarLeftRG::TO_GRAMMAR_LEFT_RG;
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToLeftRG.h b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
similarity index 80%
rename from alib2algo/src/automaton/convert/ToLeftRG.h
rename to alib2algo/src/automaton/convert/ToGrammarLeftRG.h
index 881e35f73f9e6a6cded110a8ebb25663b754d338..7ac91177ceec66ecced6abdfab889a1273d79a4e 100644
--- a/alib2algo/src/automaton/convert/ToLeftRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
@@ -1,12 +1,12 @@
/*
- * ToLeftRG.h
+ * ToGrammarLeftRG.h
*
* Created on: 9. 2. 2014
- * Author: Tomas Pecka
+ * Author: ToGrammarmas Pecka
*/
-#ifndef __TO_LEFT_RG_H__
-#define __TO_LEFT_RG_H__
+#ifndef __TO_GRAMMAR_LEFT_RG_H__
+#define __TO_GRAMMAR_LEFT_RG_H__
#include <grammar/Regular/LeftRG.h>
#include <automaton/FSM/NFA.h>
@@ -23,7 +23,7 @@ namespace convert {
* Finite automaton to right regular grammar converter.
* Source: My own :)
*/
-class ToLeftRG : public automaton::VisitableConstFSMBase {
+class ToGrammarLeftRG : public automaton::VisitableConstFSMBase {
public:
/**
* Performs conversion.
@@ -42,11 +42,11 @@ private:
void Visit(void*, const automaton::ExtendedNFA& automaton) const;
void Visit(void*, const automaton::CompactNFA& automaton) const;
- static const ToLeftRG TO_LEFT_RG;
+ static const ToGrammarLeftRG TO_GRAMMAR_LEFT_RG;
};
} /* namespace convert */
} /* namespace automaton */
-#endif /* __TO_LEFT_RG_H__ */
+#endif /* __TO_GRAMMAR_LEFT_RG_H__ */
diff --git a/alib2algo/src/automaton/convert/ToRightRG.cpp b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
similarity index 80%
rename from alib2algo/src/automaton/convert/ToRightRG.cpp
rename to alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
index e08935f2f50ccc1067b13f5b758a6272098b0da9..d3f3e8223be8df215e40fc9f5b39c1b8d30c5b65 100644
--- a/alib2algo/src/automaton/convert/ToRightRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
@@ -1,11 +1,11 @@
/*
- * ToRightRG.cpp
+ * ToGrammarRightRG.cpp
*
* Created on: 9. 2. 2014
- * Author: Tomas Pecka
+ * Author: ToGrammarmas Pecka
*/
-#include "ToRightRG.h"
+#include "ToGrammarRightRG.h"
#include <alphabet/LabeledSymbol.h>
#include <exception/AlibException.h>
@@ -13,7 +13,7 @@ namespace automaton {
namespace convert {
-grammar::RightRG ToRightRG::convert(const automaton::NFA& automaton)
+grammar::RightRG ToGrammarRightRG::convert(const automaton::NFA& automaton)
{
std::map<automaton::State, alphabet::Symbol> nonterminalMap;
@@ -58,7 +58,7 @@ grammar::RightRG ToRightRG::convert(const automaton::NFA& automaton)
return grammar;
}
-grammar::RightRG ToRightRG::convert(const automaton::DFA& automaton)
+grammar::RightRG ToGrammarRightRG::convert(const automaton::DFA& automaton)
{
std::map<automaton::State, alphabet::Symbol> nonterminalMap;
@@ -102,40 +102,40 @@ grammar::RightRG ToRightRG::convert(const automaton::DFA& automaton)
return grammar;
}
-grammar::Grammar ToRightRG::convert(const automaton::Automaton& automaton) {
+grammar::Grammar ToGrammarRightRG::convert(const automaton::Automaton& automaton) {
grammar::Grammar* out = NULL;
- automaton.getData().Accept((void*) &out, ToRightRG::TO_RIGHT_RG);
+ automaton.getData().Accept((void*) &out, ToGrammarRightRG::TO_GRAMMAR_RIGHT_RG);
grammar::Grammar res = std::move(*out);
delete out;
return res;
}
-void ToRightRG::Visit(void*, const automaton::EpsilonNFA& ) const {
+void ToGrammarRightRG::Visit(void*, const automaton::EpsilonNFA& ) const {
throw exception::AlibException("Unsupported automaton type EpsilonNFA");
}
-void ToRightRG::Visit(void*, const automaton::MultiInitialStateNFA& ) const {
+void ToGrammarRightRG::Visit(void*, const automaton::MultiInitialStateNFA& ) const {
throw exception::AlibException("Unsupported automaton type MultiInitialStateNFA");
}
-void ToRightRG::Visit(void* data, const automaton::NFA& automaton) const {
+void ToGrammarRightRG::Visit(void* data, const automaton::NFA& automaton) const {
grammar::Grammar* & out = *((grammar::Grammar**) data);
out = new grammar::Grammar(this->convert(automaton));
}
-void ToRightRG::Visit(void* data, const automaton::DFA& automaton) const {
+void ToGrammarRightRG::Visit(void* data, const automaton::DFA& automaton) const {
grammar::Grammar* & out = *((grammar::Grammar**) data);
out = new grammar::Grammar(this->convert(automaton));
}
-void ToRightRG::Visit(void*, const automaton::ExtendedNFA& ) const {
+void ToGrammarRightRG::Visit(void*, const automaton::ExtendedNFA& ) const {
throw exception::AlibException("Unsupported automaton type ExtendedNFA");
}
-void ToRightRG::Visit(void*, const automaton::CompactNFA& ) const {
+void ToGrammarRightRG::Visit(void*, const automaton::CompactNFA& ) const {
throw exception::AlibException("Unsupported automaton type CompactNFA");
}
-const ToRightRG ToRightRG::TO_RIGHT_RG;
+const ToGrammarRightRG ToGrammarRightRG::TO_GRAMMAR_RIGHT_RG;
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToRightRG.h b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
similarity index 82%
rename from alib2algo/src/automaton/convert/ToRightRG.h
rename to alib2algo/src/automaton/convert/ToGrammarRightRG.h
index c29795825dc149e94060fbc84f5ac3b0b0ae8f52..448e32e38cb9f9282e733e859da2a37484020b57 100644
--- a/alib2algo/src/automaton/convert/ToRightRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
@@ -1,12 +1,12 @@
/*
- * ToRightRG.h
+ * ToGrammarRightRG.h
*
* Created on: 9. 2. 2014
* Author: Tomas Pecka
*/
-#ifndef __TO_RIGHT_RG_H__
-#define __TO_RIGHT_RG_H__
+#ifndef __TO_GRAMMAR_RIGHT_RG_H__
+#define __TO_GRAMMAR_RIGHT_RG_H__
#include <grammar/Regular/RightRG.h>
#include <automaton/FSM/NFA.h>
@@ -23,7 +23,7 @@ namespace convert {
* Finite automaton to right regular grammar converter.
* Source: Melichar 2.104
*/
-class ToRightRG : public automaton::VisitableConstFSMBase {
+class ToGrammarRightRG : public automaton::VisitableConstFSMBase {
public:
/**
* Performs conversion.
@@ -42,11 +42,11 @@ private:
void Visit(void*, const automaton::ExtendedNFA& automaton) const;
void Visit(void*, const automaton::CompactNFA& automaton) const;
- static const ToRightRG TO_RIGHT_RG;
+ static const ToGrammarRightRG TO_GRAMMAR_RIGHT_RG;
};
} /* namespace convert */
} /* namespace automaton */
-#endif /* __TO_RIGHT_RG_H__ */
+#endif /* __TO_GRAMMAR_RIGHT_RG_H__ */
diff --git a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
index 86ac929536a9a5ece30a2291aa3669addfe67338..54d1f89f7bf7c424d2b0d1033c7dc49c4b6b408b 100644
--- a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
@@ -5,8 +5,8 @@
* Author: Tomas Pecka
*/
-#ifndef TO_REG_EXP_ALGEBRAIC_H_
-#define TO_REG_EXP_ALGEBRAIC_H_
+#ifndef AUTOMATON_TO_REG_EXP_ALGEBRAIC_H_
+#define AUTOMATON_TO_REG_EXP_ALGEBRAIC_H_
#include <deque>
#include <map>
@@ -55,4 +55,4 @@ private:
} /* namespace automaton */
-#endif /* TO_REG_EXP_ALGEBRAIC_H_ */
+#endif /* AUTOMATON_TO_REG_EXP_ALGEBRAIC_H_ */
diff --git a/alib2algo/src/automaton/properties/EpsilonClosure.cpp b/alib2algo/src/automaton/properties/EpsilonClosure.cpp
index 91758e4f8672d6bb2779d31e3c4f467a3f4333da..b91b08d470cf3b64a12d9acc6b2334f9a435ef98 100644
--- a/alib2algo/src/automaton/properties/EpsilonClosure.cpp
+++ b/alib2algo/src/automaton/properties/EpsilonClosure.cpp
@@ -96,7 +96,7 @@ std::set<automaton::State> EpsilonClosure::epsilonClosure( const automaton::Exte
closure.insert( p );
for( const auto & transition : fsm.getTransitions( ) )
- if( transition.first.first == p && regexp::RegExpEpsilon::languageContainsEpsilon( transition.first.second ) )
+ if( transition.first.first == p && regexp::properties::RegExpEpsilon::languageContainsEpsilon( transition.first.second ) )
for (const auto & to : transition.second )
if( visited [ to ] == false )
queue.push( to );
diff --git a/alib2algo/src/grammar/toAutomaton/RGtoFA.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
similarity index 84%
rename from alib2algo/src/grammar/toAutomaton/RGtoFA.cpp
rename to alib2algo/src/grammar/convert/ToAutomaton.cpp
index d18ffdada6efff06b9ad9acbe39cf27fbb07ca60..e7c6938db3695bb8da8b91328c2dc97959763877 100644
--- a/alib2algo/src/grammar/toAutomaton/RGtoFA.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -1,30 +1,28 @@
/*
- * RGtoFA.cpp
+ * ToAutomaton.cpp
*
* Created on: 1. 11. 2013
* Author: Tomas Pecka
*/
-#include "RGtoFA.h"
+#include "ToAutomaton.h"
#include <alphabet/LabeledSymbol.h>
#include <exception/AlibException.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2fa
-{
+namespace convert {
-automaton::Automaton RGtoFA::convert(const grammar::Grammar& grammar)
+automaton::Automaton ToAutomaton::convert(const grammar::Grammar& grammar)
{
automaton::Automaton* out = NULL;
- grammar.getData().Accept((void*) &out, RGtoFA::RG_TO_FA_CONVERSION);
+ grammar.getData().Accept((void*) &out, ToAutomaton::TO_AUTOMATON);
automaton::Automaton res = std::move(*out);
delete out;
return res;
}
-automaton::NFA RGtoFA::convert(const grammar::LeftRG& grammar)
+automaton::NFA ToAutomaton::convert(const grammar::LeftRG& grammar)
{
std::map<alphabet::Symbol, automaton::State> stateMap;
std::set<automaton::State> states;
@@ -71,7 +69,7 @@ automaton::NFA RGtoFA::convert(const grammar::LeftRG& grammar)
return automaton;
}
-automaton::NFA RGtoFA::convert(const grammar::RightRG& grammar)
+automaton::NFA ToAutomaton::convert(const grammar::RightRG& grammar)
{
std::map<alphabet::Symbol, automaton::State> stateMap;
std::set<automaton::State> states;
@@ -119,30 +117,30 @@ automaton::NFA RGtoFA::convert(const grammar::RightRG& grammar)
return automaton;
}
-void RGtoFA::Visit(void* userData, const grammar::RightRG& grammar) const
+void ToAutomaton::Visit(void* userData, const grammar::RightRG& grammar) const
{
automaton::Automaton* & out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(grammar));
}
-void RGtoFA::Visit(void* userData, const grammar::LeftRG& grammar) const
+void ToAutomaton::Visit(void* userData, const grammar::LeftRG& grammar) const
{
automaton::Automaton* & out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(grammar));
}
-void RGtoFA::Visit(void*, const grammar::RightLG&) const
+void ToAutomaton::Visit(void*, const grammar::RightLG&) const
{
throw exception::AlibException("Unsupported grammar type RightLG");
}
-void RGtoFA::Visit(void*, const grammar::LeftLG&) const
+void ToAutomaton::Visit(void*, const grammar::LeftLG&) const
{
throw exception::AlibException("Unsupported grammar type LeftLG");
}
-const RGtoFA RGtoFA::RG_TO_FA_CONVERSION;
+const ToAutomaton ToAutomaton::TO_AUTOMATON;
-} /* namespace rg2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
diff --git a/alib2algo/src/grammar/toAutomaton/RGtoFA.h b/alib2algo/src/grammar/convert/ToAutomaton.h
similarity index 77%
rename from alib2algo/src/grammar/toAutomaton/RGtoFA.h
rename to alib2algo/src/grammar/convert/ToAutomaton.h
index d88359532b2862ca676e46e988f4aa43e9dab1dc..2f069ef9e6c84b6ed0785b13aea7fbacde2c032e 100644
--- a/alib2algo/src/grammar/toAutomaton/RGtoFA.h
+++ b/alib2algo/src/grammar/convert/ToAutomaton.h
@@ -1,12 +1,12 @@
/*
- * RGtoFA.h
+ * ToAutomaton.h
*
* Created on: 1. 11. 2013
* Author: Tomas Pecka
*/
-#ifndef __RGTOFA_H__
-#define __RGTOFA_H__
+#ifndef _TO_AUTOMATON_H_
+#define _TO_AUTOMATON_H_
#include <grammar/Grammar.h>
#include <grammar/Regular/LeftRG.h>
@@ -15,17 +15,15 @@
#include <automaton/Automaton.h>
#include <automaton/FSM/NFA.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2fa
-{
+namespace convert {
/**
* Converts regular grammar to nondeterministic finite automaton.
* Sources: Melichar 2.98 (RightRG -> NFA) and 2.102 (LeftRG -> NFA).
*/
-class RGtoFA : public grammar::VisitableConstRGBase
+class ToAutomaton : public grammar::VisitableConstRGBase
{
public:
/**
@@ -44,11 +42,11 @@ private:
void Visit(void*, const grammar::RightLG& grammar) const;
void Visit(void*, const grammar::LeftLG& grammar) const;
- static const RGtoFA RG_TO_FA_CONVERSION;
+ static const ToAutomaton TO_AUTOMATON;
};
-} /* namespace rg2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
-#endif /* __RGTOFA_H__ */
+#endif /* _TO_AUTOMATON_H_ */
diff --git a/alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.cpp b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
similarity index 72%
rename from alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.cpp
rename to alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
index 71bbf621fc4a4eed164601a6e0303c0b38db0645..e0eaa76cc0562710eb82fc113ee8680d30d336c3 100644
--- a/alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.cpp
@@ -1,30 +1,28 @@
/*
- * RightToLeftRegularGrammar.cpp
+ * ToGrammarLeftRG.cpp
*
* Created on: 8. 3. 2014
* Author: Tomas Pecka
*/
-#include "RightToLeftRegularGrammar.h"
+#include "ToGrammarLeftRG.h"
#include <exception/AlibException.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2rg
-{
+namespace convert {
-grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::Grammar& grammar)
+grammar::LeftRG ToGrammarLeftRG::convert(const grammar::Grammar& grammar)
{
grammar::LeftRG* out = NULL;
- grammar.getData().Accept((void*) &out, RightToLeftRegularGrammar::RIGHT_TO_LEFT_REGULAR_GRAMMAR);
+ grammar.getData().Accept((void*) &out, ToGrammarLeftRG::TO_GRAMMAR_LEFT_RG);
grammar::LeftRG res = std::move(*out);
delete out;
return res;
}
-grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::RightRG& grammar)
+grammar::LeftRG ToGrammarLeftRG::convert(const grammar::RightRG& grammar)
{
// 1.
alphabet::Symbol s = alphabet::createUniqueSymbol( grammar.getInitialSymbol( ), grammar.getNonterminalAlphabet(), grammar.getTerminalAlphabet() );
@@ -73,30 +71,30 @@ grammar::LeftRG RightToLeftRegularGrammar::convert(const grammar::RightRG& gramm
return lrg;
}
-void RightToLeftRegularGrammar::Visit(void* userData, const grammar::RightRG& grammar) const
+void ToGrammarLeftRG::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
+void ToGrammarLeftRG::Visit(void*, const grammar::LeftRG&) const
{
throw exception::AlibException("Unsupported grammar type RightRG");
}
-void RightToLeftRegularGrammar::Visit(void*, const grammar::RightLG&) const
+void ToGrammarLeftRG::Visit(void*, const grammar::RightLG&) const
{
throw exception::AlibException("Unsupported grammar type RightLG");
}
-void RightToLeftRegularGrammar::Visit(void*, const grammar::LeftLG&) const
+void ToGrammarLeftRG::Visit(void*, const grammar::LeftLG&) const
{
throw exception::AlibException("Unsupported grammar type LeftLG");
}
-const RightToLeftRegularGrammar RightToLeftRegularGrammar::RIGHT_TO_LEFT_REGULAR_GRAMMAR;
+const ToGrammarLeftRG ToGrammarLeftRG::TO_GRAMMAR_LEFT_RG;
-} /* namespace rg2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
diff --git a/alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.h b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
similarity index 67%
rename from alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.h
rename to alib2algo/src/grammar/convert/ToGrammarLeftRG.h
index a965dc3926751e910b2a6efe2749e59512b254fe..58648f091a7eb5a12177d5a430586a270cc6a96b 100644
--- a/alib2algo/src/grammar/toGrammar/RightToLeftRegularGrammar.h
+++ b/alib2algo/src/grammar/convert/ToGrammarLeftRG.h
@@ -1,27 +1,25 @@
/*
- * RightToLeftRegularGrammar.h
+ * ToGrammarLeftRG.h
*
* Created on: 8. 3. 2014
* Author: Tomas Pecka
*/
-#ifndef RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
-#define RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_
+#ifndef TO_GRAMMAR_LEFT_RG_H_
+#define TO_GRAMMAR_LEFT_RG_H_
#include <grammar/Grammar.h>
#include <grammar/Regular/LeftRG.h>
#include <grammar/Regular/RightRG.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2rg
-{
+namespace convert {
/**
* Converts right regular grammar to left regular grammar.
*/
-class RightToLeftRegularGrammar : public grammar::VisitableConstRGBase
+class ToGrammarLeftRG : public grammar::VisitableConstRGBase
{
public:
/**
@@ -38,11 +36,11 @@ private:
void Visit(void*, const grammar::RightLG& grammar) const;
void Visit(void*, const grammar::LeftLG& grammar) const;
- static const RightToLeftRegularGrammar RIGHT_TO_LEFT_REGULAR_GRAMMAR;
+ static const ToGrammarLeftRG TO_GRAMMAR_LEFT_RG;
};
-} /* namespace rg2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
-#endif /* RIGHT_TO_LEFT_REGULAR_GRAMMAR_H_ */
+#endif /* TO_GRAMMAR_LEFT_RG_H_ */
diff --git a/alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.cpp b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
similarity index 72%
rename from alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.cpp
rename to alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
index b784f0e5c03890be0b380aa067aeda5303706257..ae81d66fb1c4aa033c50964d9ecd8414199d9a24 100644
--- a/alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.cpp
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.cpp
@@ -1,28 +1,28 @@
/*
- * LeftToRightRegularGrammar.cpp
+ * ToGrammarRightRG.cpp
*
* Created on: 8. 3. 2014
* Author: Tomas Pecka
*/
-#include "LeftToRightRegularGrammar.h"
+#include "ToGrammarRightRG.h"
#include <exception/AlibException.h>
-namespace conversions {
+namespace grammar {
-namespace rg2rg {
+namespace convert {
-grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::Grammar& grammar)
+grammar::RightRG ToGrammarRightRG::convert(const grammar::Grammar& grammar)
{
grammar::RightRG* out = NULL;
- grammar.getData().Accept((void*) &out, LeftToRightRegularGrammar::LEFT_TO_RIGHT_REGULAR_GRAMMAR);
+ grammar.getData().Accept((void*) &out, ToGrammarRightRG::TO_GRAMMAR_RIGHT_RG);
grammar::RightRG res = std::move(*out);
delete out;
return res;
}
-grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::LeftRG& grammar)
+grammar::RightRG ToGrammarRightRG::convert(const grammar::LeftRG& grammar)
{
// 1.
alphabet::Symbol s = alphabet::createUniqueSymbol( grammar.getInitialSymbol( ), grammar.getNonterminalAlphabet(), grammar.getTerminalAlphabet() );
@@ -71,29 +71,29 @@ grammar::RightRG LeftToRightRegularGrammar::convert(const grammar::LeftRG& gramm
return rrg;
}
-void LeftToRightRegularGrammar::Visit(void*, const grammar::RightRG&) const
+void ToGrammarRightRG::Visit(void*, const grammar::RightRG&) const
{
throw exception::AlibException("Unsupported grammar type RightRG");
}
-void LeftToRightRegularGrammar::Visit(void* userData, const grammar::LeftRG& grammar) const
+void ToGrammarRightRG::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
+void ToGrammarRightRG::Visit(void*, const grammar::RightLG&) const
{
throw exception::AlibException("Unsupported grammar type RightLG");
}
-void LeftToRightRegularGrammar::Visit(void*, const grammar::LeftLG&) const
+void ToGrammarRightRG::Visit(void*, const grammar::LeftLG&) const
{
throw exception::AlibException("Unsupported grammar type LeftLG");
}
-const LeftToRightRegularGrammar LeftToRightRegularGrammar::LEFT_TO_RIGHT_REGULAR_GRAMMAR;
+const ToGrammarRightRG ToGrammarRightRG::TO_GRAMMAR_RIGHT_RG;
-} /* namespace rg2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
diff --git a/alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.h b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
similarity index 67%
rename from alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.h
rename to alib2algo/src/grammar/convert/ToGrammarRightRG.h
index 350eef77aa296b3291b26245aed3e4399bd156c9..468b72aa3a8fac45598d0d68ce16fafce45ab5af 100644
--- a/alib2algo/src/grammar/toGrammar/LeftToRightRegularGrammar.h
+++ b/alib2algo/src/grammar/convert/ToGrammarRightRG.h
@@ -1,26 +1,25 @@
/*
- * LeftToRightRegularGrammar.h
+ * ToGrammarRightRG.h
*
* Created on: 8. 3. 2014
* Author: Tomas Pecka
*/
-#ifndef LEFT_TORIGHT_REGULAR_GRAMMAR_H_
-#define LEFT_TORIGHT_REGULAR_GRAMMAR_H_
+#ifndef TO_GRAMMAR_RIGHT_RG_H_
+#define TO_GRAMMAR_RIGHT_RG_H_
#include <grammar/Grammar.h>
#include <grammar/Regular/LeftRG.h>
#include <grammar/Regular/RightRG.h>
-namespace conversions{
+namespace grammar {
-namespace rg2rg
-{
+namespace convert {
/**
* Converts left regular grammar to right regular grammar.
*/
-class LeftToRightRegularGrammar : public grammar::VisitableConstRGBase
+class ToGrammarRightRG : public grammar::VisitableConstRGBase
{
public:
/**
@@ -37,11 +36,11 @@ private:
void Visit(void*, const grammar::RightLG& grammar) const;
void Visit(void*, const grammar::LeftLG& grammar) const;
- static const LeftToRightRegularGrammar LEFT_TO_RIGHT_REGULAR_GRAMMAR;
+ static const ToGrammarRightRG TO_GRAMMAR_RIGHT_RG;
};
-} /* namespace rg2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
-#endif /* LEFT_TO_RIGHT_REGULAR_GRAMMAR_H_ */
+#endif /* TO_GRAMMAR_RIGHT_RG_H_ */
diff --git a/alib2algo/src/grammar/toRegexp/Algebraic.cpp b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
similarity index 77%
rename from alib2algo/src/grammar/toRegexp/Algebraic.cpp
rename to alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
index cdef84a2159881e4153bc58198207787efdb4982..5deb9296f085beec26595d62bf97aa986aac94c4 100644
--- a/alib2algo/src/grammar/toRegexp/Algebraic.cpp
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
@@ -1,11 +1,11 @@
/*
- * Algebraic.cpp
+ * ToRegExpAlgebraic.cpp
*
* Created on: 4. 3. 2014
* Author: Tomas Pecka
*/
-#include "Algebraic.h"
+#include "ToRegExpAlgebraic.h"
#include "../../equations/LeftRegularEquationSolver.h"
#include "../../equations/RightRegularEquationSolver.h"
@@ -13,22 +13,20 @@
#include <exception/AlibException.h>
#include <regexp/unbounded/UnboundedRegExpElements.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2re
-{
+namespace convert {
-regexp::RegExp Algebraic::convert(const grammar::Grammar& grammar)
+regexp::RegExp ToRegExpAlgebraic::convert(const grammar::Grammar& grammar)
{
regexp::RegExp* out = NULL;
- grammar.getData().Accept((void*) &out, Algebraic::RG_TO_RE_ALGEBRAIC);
+ grammar.getData().Accept((void*) &out, ToRegExpAlgebraic::TO_REG_EXP_ALGEBRAIC);
regexp::RegExp res = std::move(*out);
delete out;
return res;
}
-regexp::RegExp Algebraic::convert(const grammar::LeftRG& grammar)
+regexp::RegExp ToRegExpAlgebraic::convert(const grammar::LeftRG& grammar)
{
equations::LeftRegularEquationSolver solver;
@@ -58,7 +56,7 @@ regexp::RegExp Algebraic::convert(const grammar::LeftRG& grammar)
return regexp::RegExp{solver.solve(grammar.getInitialSymbol())};
}
-regexp::RegExp Algebraic::convert(const grammar::RightRG& grammar)
+regexp::RegExp ToRegExpAlgebraic::convert(const grammar::RightRG& grammar)
{
equations::RightRegularEquationSolver solver;
@@ -89,30 +87,30 @@ regexp::RegExp Algebraic::convert(const grammar::RightRG& grammar)
return regexp::RegExp{solver.solve(grammar.getInitialSymbol())};
}
-void Algebraic::Visit(void* userData, const grammar::RightRG& grammar) const
+void ToRegExpAlgebraic::Visit(void* userData, const grammar::RightRG& grammar) const
{
regexp::RegExp* & out = *((regexp::RegExp**) userData);
out = new regexp::RegExp(this->convert(grammar));
}
-void Algebraic::Visit(void* userData, const grammar::LeftRG& grammar) const
+void ToRegExpAlgebraic::Visit(void* userData, const grammar::LeftRG& grammar) const
{
regexp::RegExp* & out = *((regexp::RegExp**) userData);
out = new regexp::RegExp(this->convert(grammar));
}
-void Algebraic::Visit(void*, const grammar::RightLG&) const
+void ToRegExpAlgebraic::Visit(void*, const grammar::RightLG&) const
{
throw exception::AlibException("Unsupported grammar type RightLG");
}
-void Algebraic::Visit(void*, const grammar::LeftLG&) const
+void ToRegExpAlgebraic::Visit(void*, const grammar::LeftLG&) const
{
throw exception::AlibException("Unsupported grammar type LeftLG");
}
-const Algebraic Algebraic::RG_TO_RE_ALGEBRAIC;
+const ToRegExpAlgebraic ToRegExpAlgebraic::TO_REG_EXP_ALGEBRAIC;
-} /* namespace rg2re */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace grammar */
diff --git a/alib2algo/src/grammar/toRegexp/Algebraic.h b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
similarity index 69%
rename from alib2algo/src/grammar/toRegexp/Algebraic.h
rename to alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
index bd4741d891fc06927fcda73a3a6b229978bc165f..3370fc3dfd51c874edf9cefb109710e21294ab74 100644
--- a/alib2algo/src/grammar/toRegexp/Algebraic.h
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
@@ -1,12 +1,12 @@
/*
- * Algebraic.h
+ * ToRegExpAlgebraic.h
*
* Created on: 4. 3. 2014
* Author: Tomas Pecka
*/
-#ifndef RG2RE_ALGEBRAIC_H_
-#define RG2RE_ALGEBRAIC_H_
+#ifndef GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_
+#define GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_
#include <grammar/Grammar.h>
#include <grammar/Regular/RightRG.h>
@@ -14,13 +14,11 @@
#include <regexp/RegExp.h>
-namespace conversions
-{
+namespace grammar {
-namespace rg2re
-{
+namespace convert {
-class Algebraic : public grammar::VisitableConstRGBase
+class ToRegExpAlgebraic : public grammar::VisitableConstRGBase
{
public:
/**
@@ -38,11 +36,11 @@ protected:
void Visit(void*, const grammar::RightLG& grammar) const;
void Visit(void*, const grammar::LeftLG& grammar) const;
- static const Algebraic RG_TO_RE_ALGEBRAIC;
+ static const ToRegExpAlgebraic TO_REG_EXP_ALGEBRAIC;
};
-} /* namespace rg2re */
+} /* namespace covert */
-} /* namespace conversions */
+} /* namespace grammar */
-#endif /* RG2RE_ALGEBRAIC_H_ */
+#endif /* GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_ */
diff --git a/alib2algo/src/regexp/GlushkovTraversal.cpp b/alib2algo/src/regexp/GlushkovTraversal.cpp
index 453d059bb88a87467e4afa33e44421e6c757572d..b622ed1a01b315c4cd03eac7e3ade2fd37d101bb 100644
--- a/alib2algo/src/regexp/GlushkovTraversal.cpp
+++ b/alib2algo/src/regexp/GlushkovTraversal.cpp
@@ -112,7 +112,7 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::first( regexp::Unb
tmp = first( element );
ret.insert( tmp.begin( ), tmp.end( ) );
- if(! regexp::RegExpEpsilon::languageContainsEpsilon(*element)) // If regexp of this subtree can match epsilon, then we need to add next subtree
+ if(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(*element)) // If regexp of this subtree can match epsilon, then we need to add next subtree
break;
}
@@ -188,7 +188,7 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::last( regexp::Unbo
tmp = last( *it );
ret.insert( tmp.begin( ), tmp.end( ) );
- if( ! regexp::RegExpEpsilon::languageContainsEpsilon(**it) )
+ if( ! regexp::properties::RegExpEpsilon::languageContainsEpsilon(**it) )
break;
}
@@ -276,7 +276,7 @@ set<regexp::UnboundedRegExpSymbol const *> GlushkovTraversal::follow( regexp::Un
tmp = first( *f );
ret.insert( tmp.begin( ), tmp.end( ) );
- if( ! regexp::RegExpEpsilon::languageContainsEpsilon( **f ) )
+ if( ! regexp::properties::RegExpEpsilon::languageContainsEpsilon( **f ) )
break;
}
}
diff --git a/alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
similarity index 74%
rename from alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.cpp
rename to alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index 3d678c72a569da86fb1cb2ee339f4cfba8f38a95..388f7a98d1921db13fcb8a85c77a9e49ca7307e7 100644
--- a/alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
@@ -1,11 +1,11 @@
/*
- * BrzozowskiDerivation.cpp
+ * ToAutomatonDerivation.cpp
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#include "BrzozowskiDerivation.h"
+#include "ToAutomatonDerivation.h"
#include <set>
#include <deque>
@@ -19,23 +19,21 @@
#include "../simplify/RegExpOptimize.h"
#include "../properties/RegExpEpsilon.h"
-namespace conversions
-{
+namespace regexp {
-namespace re2fa
-{
+namespace convert {
-automaton::Automaton BrzozowskiDerivation::convert(const regexp::RegExp& regexp)
+automaton::Automaton ToAutomatonDerivation::convert(const regexp::RegExp& regexp)
{
automaton::Automaton* out = NULL;
- regexp.getData().Accept((void*) &out, BrzozowskiDerivation::BRZOZOWSKI_DERIVATION);
+ regexp.getData().Accept((void*) &out, ToAutomatonDerivation::TO_AUTOMATON_DERIVATION);
automaton::Automaton res = std::move(*out);
delete out;
return res;
}
template<class T>
-automaton::NFA BrzozowskiDerivation::convert(const T& regexp)
+automaton::NFA ToAutomatonDerivation::convert(const T& regexp)
{
// 1.
regexp::RegExpOptimize opt;
@@ -111,29 +109,29 @@ automaton::NFA BrzozowskiDerivation::convert(const T& regexp)
for(const auto& r : Q)
{
- if(regexp::RegExpEpsilon::languageContainsEpsilon(r))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(r))
automaton.addFinalState(stateMap.find(r)->second);
}
return automaton;
}
-template automaton::NFA BrzozowskiDerivation::convert(const regexp::FormalRegExp& regexp);
-template automaton::NFA BrzozowskiDerivation::convert(const regexp::UnboundedRegExp& regexp);
+template automaton::NFA ToAutomatonDerivation::convert(const regexp::FormalRegExp& regexp);
+template automaton::NFA ToAutomatonDerivation::convert(const regexp::UnboundedRegExp& regexp);
-void BrzozowskiDerivation::Visit(void* userData, const regexp::FormalRegExp& regexp) const
+void ToAutomatonDerivation::Visit(void* userData, const regexp::FormalRegExp& regexp) const
{
automaton::Automaton* &out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(regexp));
}
-void BrzozowskiDerivation::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
+void ToAutomatonDerivation::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
{
automaton::Automaton* &out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(regexp));
}
-const BrzozowskiDerivation BrzozowskiDerivation::BRZOZOWSKI_DERIVATION;
+const ToAutomatonDerivation ToAutomatonDerivation::TO_AUTOMATON_DERIVATION;
-} /* namespace re2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.h b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
similarity index 67%
rename from alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.h
rename to alib2algo/src/regexp/convert/ToAutomatonDerivation.h
index a3c249dfe7ab5465b2547b4100af12c1139a50f6..7b26ff65f4d23332521b1e7e02b05748d756bf71 100644
--- a/alib2algo/src/regexp/toAutomaton/BrzozowskiDerivation.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
@@ -1,12 +1,12 @@
/*
- * BrzozowskiDerivation.h
+ * ToAutomatonDerivation.h
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#ifndef RE2FA_BRZOZOWSKIDERIVATION_H_
-#define RE2FA_BRZOZOWSKIDERIVATION_H_
+#ifndef TO_AUTOMATON_DERIVATION_H_
+#define TO_AUTOMATON_DERIVATION_H_
#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
@@ -15,17 +15,15 @@
#include <automaton/Automaton.h>
#include <automaton/FSM/NFA.h>
-namespace conversions
-{
+namespace regexp {
-namespace re2fa
-{
+namespace convert {
/**
* Converts regular expression to finite automaton using BrzozowskiDerivation algorithm (derivations of regular expressions).
* Source: Melichar 2.110
*/
-class BrzozowskiDerivation : public regexp::VisitableRegExpBase::const_visitor_type
+class ToAutomatonDerivation : public regexp::VisitableRegExpBase::const_visitor_type
{
public:
/**
@@ -41,11 +39,11 @@ private:
void Visit(void* , const regexp::FormalRegExp& regexp) const;
void Visit(void* , const regexp::UnboundedRegExp& regexp) const;
- static const BrzozowskiDerivation BRZOZOWSKI_DERIVATION;
+ static const ToAutomatonDerivation TO_AUTOMATON_DERIVATION;
};
-} /* namespace re2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
-#endif /* RE2FA_BRZOZOWSKIDERIVATION_H_ */
+#endif /* TO_AUTOMATON_DERIVATION_H_ */
diff --git a/alib2algo/src/regexp/toAutomaton/GlushkovNFA.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
similarity index 68%
rename from alib2algo/src/regexp/toAutomaton/GlushkovNFA.cpp
rename to alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index 56c73aa1e3fbaffe56dd46ee4e8f59810e66918a..7f25196efdb89151e60ddb879ce93df8f3136763 100644
--- a/alib2algo/src/regexp/toAutomaton/GlushkovNFA.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -1,11 +1,11 @@
/*
- * GlushkovNFA.cpp
+ * ToAutomatonGlushkov.cpp
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#include "GlushkovNFA.h"
+#include "ToAutomatonGlushkov.h"
#include "label/Label.h"
#include "label/LabelPairLabel.h"
@@ -16,19 +16,19 @@
#include "../properties/RegExpEpsilon.h"
-namespace conversions{
+namespace regexp {
-namespace re2fa {
+namespace convert {
-automaton::NFA GlushkovNFA::convert(const regexp::RegExp& regexp) {
+automaton::NFA ToAutomatonGlushkov::convert(const regexp::RegExp& regexp) {
automaton::NFA* out = nullptr;
- regexp.getData().Accept((void*) &out, GlushkovNFA::GLUSHKOV_NFA);
+ regexp.getData().Accept((void*) &out, ToAutomatonGlushkov::TO_AUTOMATON_GLUSHKOV);
automaton::NFA res = std::move(*out);
delete out;
return res;
}
-automaton::NFA GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
+automaton::NFA ToAutomatonGlushkov::convert(const regexp::UnboundedRegExp& regexp)
{
automaton::State q0( label::Label( label::LabelPairLabel( std::make_pair( label::labelFrom( 'q' ), label::labelFrom( 0 ) ) ) ) );
automaton::NFA automaton( q0 );
@@ -38,9 +38,9 @@ automaton::NFA GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
automaton.addInputSymbol( symbol );
// steps 2, 3, 4
- std::set<regexp::GlushkovPair> pairs;
- const std::set<regexp::GlushkovSymbol> first = regexp::GlushkovTraversal::first(regexp);
- const std::set<regexp::GlushkovSymbol> last = regexp::GlushkovTraversal::last(regexp);
+ std::set<regexp::GlushkovPair> pairs;
+ const std::set<regexp::GlushkovSymbol> first = regexp::GlushkovTraversal::first(regexp);
+ const std::set<regexp::GlushkovSymbol> last = regexp::GlushkovTraversal::last(regexp);
for( auto const& x : regexp::GlushkovTraversal::getSymbols( regexp ) )
for( auto const& f : regexp::GlushkovTraversal::follow( regexp, x ) ) {
pairs.insert( regexp::GlushkovPair( x, f ) );
@@ -48,7 +48,7 @@ automaton::NFA GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
// \e in q0 check is in step 7
// step 5
- std::map<regexp::GlushkovSymbol, automaton::State> stateMap;
+ std::map<regexp::GlushkovSymbol, automaton::State> stateMap;
for( auto const& symbol : regexp::GlushkovTraversal::getSymbols( regexp ) ) {
automaton::State q( label::Label( label::LabelPairLabel( std::make_pair( label::labelFrom( symbol.getInputSymbol( ) ), label::labelFrom( symbol.getId( ) ) ) ) ) );
@@ -77,13 +77,13 @@ automaton::NFA GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
automaton.addFinalState( q );
}
- if(regexp::RegExpEpsilon::languageContainsEpsilon(regexp))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(regexp))
automaton.addFinalState( q0 );
return automaton;
}
-void GlushkovNFA::Visit(void* userData, const regexp::FormalRegExp& regexp) const
+void ToAutomatonGlushkov::Visit(void* userData, const regexp::FormalRegExp& regexp) const
{
/*
automaton::NFA* & out = *((automaton::NFA**) userData);
@@ -92,14 +92,14 @@ void GlushkovNFA::Visit(void* userData, const regexp::FormalRegExp& regexp) cons
throw exception::AlibException("Glushkov: Converting FormalRegExp NYI"); // TODO
}
-void GlushkovNFA::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
+void ToAutomatonGlushkov::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
{
automaton::NFA* & out = *((automaton::NFA**) userData);
out = new automaton::NFA(this->convert(regexp));
}
-const GlushkovNFA GlushkovNFA::GLUSHKOV_NFA;
+const ToAutomatonGlushkov ToAutomatonGlushkov::TO_AUTOMATON_GLUSHKOV;
-} /* namespace fa2re */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
new file mode 100644
index 0000000000000000000000000000000000000000..edf737ad00edd4ba0ca3f0793c44b56a6eb5cdf3
--- /dev/null
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
@@ -0,0 +1,50 @@
+/*
+ * ToAutomatonGlushkov.h
+ *
+ * Created on: 11. 1. 2014
+ * Author: Tomas Pecka
+ */
+
+#ifndef TO_AUTOMATON_GLUSHKOV_H_
+#define TO_AUTOMATON_GLUSHKOV_H_
+
+#include <map>
+
+#include <automaton/FSM/NFA.h>
+#include <regexp/RegExp.h>
+#include <regexp/formal/FormalRegExp.h>
+#include <regexp/unbounded/UnboundedRegExp.h>
+
+namespace regexp {
+
+namespace convert {
+
+/**
+ * Converts regular expression to finite automaton using Glushkov's NFA construction algorithm.
+ * Source: Melichar 2.107
+ */
+class ToAutomatonGlushkov : public regexp::VisitableRegExpBase::const_visitor_type
+{
+public:
+ /**
+ * Performs conversion.
+ * @param re Original regular expression.
+ * @return NFA equivalent to original regular expression.
+ */
+ static automaton::NFA convert(const regexp::RegExp& re);
+
+ static automaton::NFA convert(const regexp::UnboundedRegExp& re);
+ static automaton::NFA convert(const regexp::FormalRegExp& re);
+
+private:
+ void Visit(void*, const regexp::FormalRegExp& regexp) const;
+ void Visit(void*, const regexp::UnboundedRegExp& regexp) const;
+
+ static const ToAutomatonGlushkov TO_AUTOMATON_GLUSHKOV;
+};
+
+} /* namespace convert */
+
+} /* namespace regexp */
+
+#endif /* TO_AUTOMATON_GLUSHKOV_H_ */
diff --git a/alib2algo/src/regexp/toAutomaton/Thompson.cpp b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
similarity index 84%
rename from alib2algo/src/regexp/toAutomaton/Thompson.cpp
rename to alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
index b3fe522f0f88b5101de8432cfa56b841dd040145..a2b2611735233efccf2102e05f220a63527a234e 100644
--- a/alib2algo/src/regexp/toAutomaton/Thompson.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
@@ -1,36 +1,34 @@
/*
- * Thompson.cpp
+ * ToAutomatonThompson.cpp
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#include "Thompson.h"
+#include "ToAutomatonThompson.h"
#include <tuple>
-namespace conversions
-{
+namespace regexp {
-namespace re2fa
-{
+namespace convert {
-automaton::Automaton Thompson::convert(const regexp::RegExp& regexp)
+automaton::Automaton ToAutomatonThompson::convert(const regexp::RegExp& regexp)
{
automaton::Automaton* out = NULL;
- regexp.getData().Accept((void*) &out, Thompson::THOMPSON);
+ regexp.getData().Accept((void*) &out, ToAutomatonThompson::TO_AUTOMATON_THOMPSON);
automaton::Automaton res = std::move(*out);
delete out;
return res;
}
template<class T>
-automaton::EpsilonNFA Thompson::convert(const T& regexp)
+automaton::EpsilonNFA ToAutomatonThompson::convert(const T& regexp)
{ //FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> out(automaton::EpsilonNFA(automaton::State(0)), 1, nullptr, nullptr);
automaton::EpsilonNFA& automaton = std::get<0>(out);
automaton.setInputSymbols(regexp.getAlphabet());
- regexp.getRegExp().Accept((void*) &out, Thompson::THOMPSON);
+ regexp.getRegExp().Accept((void*) &out, ToAutomatonThompson::TO_AUTOMATON_THOMPSON);
automaton.setInitialState(*std::get<2>(out));
automaton.setFinalStates(std::set<automaton::State>{*std::get<3>(out)});
@@ -42,13 +40,13 @@ automaton::EpsilonNFA Thompson::convert(const T& regexp)
// ----------------------------------------------------------------------------
-void Thompson::Visit(void* userData, const regexp::FormalRegExp& regexp) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExp& regexp) const
{
automaton::Automaton* & out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(regexp));
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
{
automaton::Automaton* & out = *((automaton::Automaton**) userData);
out = new automaton::Automaton(this->convert(regexp));
@@ -56,7 +54,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExp& regexp) cons
// ----------------------------------------------------------------------------
-void Thompson::Visit(void* userData, const regexp::FormalRegExpAlternation& alternation) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpAlternation& alternation) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -78,7 +76,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpAlternation& alte
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::FormalRegExpConcatenation& concatenation) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpConcatenation& concatenation) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
@@ -95,7 +93,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpConcatenation& co
// std::get<3>(out) = std::get<3>(out);
}
-void Thompson::Visit(void* userData, const regexp::FormalRegExpIteration& iteration) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpIteration& iteration) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
@@ -116,7 +114,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpIteration& iterat
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::FormalRegExpSymbol& symbol) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpSymbol& symbol) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
@@ -132,7 +130,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpSymbol& symbol) c
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::FormalRegExpEpsilon&) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpEpsilon&) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
@@ -148,7 +146,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpEpsilon&) const
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::FormalRegExpEmpty&) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::FormalRegExpEmpty&) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
@@ -166,7 +164,7 @@ void Thompson::Visit(void* userData, const regexp::FormalRegExpEmpty&) const
// ----------------------------------------------------------------------------
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpAlternation& alternation) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpAlternation& alternation) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -187,7 +185,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpAlternation& a
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpConcatenation& concatenation) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpConcatenation& concatenation) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -206,7 +204,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpConcatenation&
std::get<3>(out) = tails[tails.size()-1].second;
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpIteration& iteration) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpIteration& iteration) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -226,7 +224,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpIteration& ite
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpSymbol& symbol) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpSymbol& symbol) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -241,7 +239,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpSymbol& symbol
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpEpsilon&) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpEpsilon&) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -256,7 +254,7 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpEpsilon&) cons
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-void Thompson::Visit(void* userData, const regexp::UnboundedRegExpEmpty&) const
+void ToAutomatonThompson::Visit(void* userData, const regexp::UnboundedRegExpEmpty&) const
{
std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*> &out = *(std::tuple<automaton::EpsilonNFA, int, const automaton::State*, const automaton::State*>*) userData;
automaton::EpsilonNFA& automaton = std::get<0>(out);
@@ -270,8 +268,8 @@ void Thompson::Visit(void* userData, const regexp::UnboundedRegExpEmpty&) const
std::get<3>(out) = &(*automaton.getStates().find(tail));
}
-const Thompson Thompson::THOMPSON;
+const ToAutomatonThompson ToAutomatonThompson::TO_AUTOMATON_THOMPSON;
-} /* namespace re2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/toAutomaton/Thompson.h b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
similarity index 81%
rename from alib2algo/src/regexp/toAutomaton/Thompson.h
rename to alib2algo/src/regexp/convert/ToAutomatonThompson.h
index e127f07f54e53f48e9691986e9f04e6d0af0f312..e2608c9b1c12adccb75c390ac621a93fe5aa92a3 100644
--- a/alib2algo/src/regexp/toAutomaton/Thompson.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
@@ -1,12 +1,12 @@
/*
- * Thompson.h
+ * ToAutomatonThompson.h
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#ifndef THOMPSON_H_
-#define THOMPSON_H_
+#ifndef TO_AUTOMATON_THOMPSON_H_
+#define TO_AUTOMATON_THOMPSON_H_
#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExpElements.h>
@@ -14,11 +14,9 @@
#include <automaton/Automaton.h>
#include <automaton/FSM/EpsilonNFA.h>
-namespace conversions
-{
+namespace regexp {
-namespace re2fa
-{
+namespace convert {
/**
* Converts regular expression to finite automaton using Thompson's Construction Algorithm (TCA).
@@ -28,7 +26,7 @@ namespace re2fa
* http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.7450&rep=rep1&type=ps
* Melichar 2.112
*/
-class Thompson : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
+class ToAutomatonThompson : public regexp::VisitableRegExpBase::const_visitor_type, regexp::FormalRegExpElement::const_visitor_type, regexp::UnboundedRegExpElement::const_visitor_type
{
public:
/**
@@ -59,11 +57,11 @@ private:
void Visit(void*, const regexp::FormalRegExpEpsilon& epsilon) const;
void Visit(void*, const regexp::FormalRegExpEmpty& empty) const;
- static const Thompson THOMPSON;
+ static const ToAutomatonThompson TO_AUTOMATON_THOMPSON;
};
-} /* namespace re2fa */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
-#endif /* THOMPSON_H_ */
+#endif /* TO_AUTOMATON_THOMPSON_H_ */
diff --git a/alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
similarity index 74%
rename from alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.cpp
rename to alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index 0f3f27d84b21543c752efd470ef3f4f2fa17e093..666183c10f3d736836cf0e51adf18305ff687fd2 100644
--- a/alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
@@ -1,11 +1,11 @@
/*
- * BrzozowskiDerivation.cpp
+ * ToGrammarRightRGDerivation.cpp
*
* Created on: 6. 3. 2014
* Author: tomas
*/
-#include "BrzozowskiDerivation.h"
+#include "ToGrammarRightRGDerivation.h"
#include <set>
#include <deque>
@@ -14,27 +14,25 @@
#include <std/hexavigesimal.h>
-#include "../../simplify/RegExpOptimize.h"
-#include "../../transform/RegExpDerivation.h"
-#include "../../properties/RegExpEpsilon.h"
+#include "../simplify/RegExpOptimize.h"
+#include "../transform/RegExpDerivation.h"
+#include "../properties/RegExpEpsilon.h"
-namespace conversions
-{
+namespace regexp {
-namespace re2rg
-{
+namespace convert {
-grammar::RightRG BrzozowskiDerivation::convert(const regexp::RegExp& regexp)
+grammar::RightRG ToGrammarRightRGDerivation::convert(const regexp::RegExp& regexp)
{
grammar::RightRG* out = NULL;
- regexp.getData().Accept((void*) &out, BrzozowskiDerivation::BRZOZOWSKI_DERIVATION);
+ regexp.getData().Accept((void*) &out, ToGrammarRightRGDerivation::TO_GRAMMAR_RIGHT_RG_DERIVATION);
grammar::RightRG res = std::move(*out);
delete out;
return res;
}
template<class T>
-grammar::RightRG BrzozowskiDerivation::convert(const T& regexp)
+grammar::RightRG ToGrammarRightRGDerivation::convert(const T& regexp)
{
// 1.
regexp::RegExp V = regexp::RegExp{regexp::RegExpOptimize::optimize(regexp)};
@@ -105,33 +103,33 @@ grammar::RightRG BrzozowskiDerivation::convert(const T& regexp)
grammar.addRule(nonterminalMap.find(r)->second, std::make_pair(a, nonterminalMap.find(derived)->second));
- if(regexp::RegExpEpsilon::languageContainsEpsilon(derived))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(derived))
grammar.addRule(nonterminalMap.find(r)->second, a);
}
}
grammar.setInitialSymbol(nonterminalMap.find(V)->second);
- if(regexp::RegExpEpsilon::languageContainsEpsilon(V))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(V))
grammar.setGeneratesEpsilon(true); // okay, because of this feature we do not have to bother with extending the grammar with new rules and nonterminals. YAY!
return grammar;
}
-void BrzozowskiDerivation::Visit(void* userData, const regexp::FormalRegExp& regexp) const
+void ToGrammarRightRGDerivation::Visit(void* userData, const regexp::FormalRegExp& regexp) const
{
grammar::RightRG* &out = *((grammar::RightRG**) userData);
out = new grammar::RightRG(this->convert(regexp));
}
-void BrzozowskiDerivation::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
+void ToGrammarRightRGDerivation::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
{
grammar::RightRG* &out = *((grammar::RightRG**) userData);
out = new grammar::RightRG(this->convert(regexp));
}
-const BrzozowskiDerivation BrzozowskiDerivation::BRZOZOWSKI_DERIVATION;
+const ToGrammarRightRGDerivation ToGrammarRightRGDerivation::TO_GRAMMAR_RIGHT_RG_DERIVATION;
-} /* namespace re2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.h b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
similarity index 63%
rename from alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.h
rename to alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
index 7a5814ad9ab02a7e4c166b5301f4582f6f676ad3..4027f7169173a6f70cfdfa406e9e8f70e2b14818 100644
--- a/alib2algo/src/regexp/toGrammar/toRightRG/BrzozowskiDerivation.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
@@ -1,29 +1,27 @@
/*
- * BrzozowskiDerivation.h
+ * ToGrammarRightRGDerivation.h
*
* Created on: 6. 3. 2014
* Author: Tomas Pecka
*/
-#ifndef RE2RG_BRZOZOWSKIDERIVATION_H_
-#define RE2RG_BRZOZOWSKIDERIVATION_H_
+#ifndef TO_GRAMMAR_RIGHT_RG_DERIVATION_H_
+#define TO_GRAMMAR_RIGHT_RG_DERIVATION_H_
#include <grammar/Regular/RightRG.h>
#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
-namespace conversions
-{
+namespace regexp {
-namespace re2rg
-{
+namespace convert {
/**
* Converts reg. expression to right regular grammar using brzozowski derivation algorithm.
* Source: Melichar 2.137
*/
-class BrzozowskiDerivation : public regexp::VisitableRegExpBase::const_visitor_type
+class ToGrammarRightRGDerivation : public regexp::VisitableRegExpBase::const_visitor_type
{
public:
/**
@@ -39,11 +37,11 @@ private:
void Visit(void*, const regexp::FormalRegExp& regexp) const;
void Visit(void*, const regexp::UnboundedRegExp& regexp) const;
- static const BrzozowskiDerivation BRZOZOWSKI_DERIVATION;
+ static const ToGrammarRightRGDerivation TO_GRAMMAR_RIGHT_RG_DERIVATION;
};
-} /* namespace re2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
-#endif /* RE2RG_BRZOZOWSKIDERIVATION_H_ */
+#endif /* TO_GRAMMAR_RIGHT_RG_DERIVATION_H_ */
diff --git a/alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
similarity index 75%
rename from alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.cpp
rename to alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index 1a1dbafa8f39c169aa82564466db64331000fe35..d60fa098d14aa782e308996db0d636ddbd8f8951 100644
--- a/alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -1,11 +1,11 @@
/*
- * Glushkov.cpp
+ * ToGrammarRightRGGlushkov.cpp
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#include "GlushkovNFA.h"
+#include "ToGrammarRightRGGlushkov.h"
#include <algorithm>
@@ -13,28 +13,26 @@
#include <label/LabelPairLabel.h>
-#include "../../GlushkovTraversal.h"
-#include "../../GlushkovPair.h"
-#include "../../GlushkovSymbol.h"
+#include "../GlushkovTraversal.h"
+#include "../GlushkovPair.h"
+#include "../GlushkovSymbol.h"
-#include "../../properties/RegExpEpsilon.h"
+#include "../properties/RegExpEpsilon.h"
-namespace conversions
-{
+namespace regexp {
-namespace re2rg
-{
+namespace convert {
-grammar::Grammar GlushkovNFA::convert(const regexp::RegExp& regexp)
+grammar::Grammar ToGrammarRightRGGlushkov::convert(const regexp::RegExp& regexp)
{
grammar::Grammar* out = NULL;
- regexp.getData().Accept((void*) &out, GlushkovNFA::GLUSHKOV_NFA);
+ regexp.getData().Accept((void*) &out, ToGrammarRightRGGlushkov::TO_GRAMMAR_RIGHT_RG_GLUSHKOV);
grammar::Grammar res = std::move(*out);
delete out;
return res;
}
-grammar::RightRG GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
+grammar::RightRG ToGrammarRightRGGlushkov::convert(const regexp::UnboundedRegExp& regexp)
{
alphabet::Symbol S = alphabet::symbolFrom("S");
grammar::RightRG grammar(S);
@@ -89,14 +87,14 @@ grammar::RightRG GlushkovNFA::convert(const regexp::UnboundedRegExp& regexp)
grammar.addRule(rule.first, rhs.at(0));
}
- if(regexp::RegExpEpsilon::languageContainsEpsilon(regexp))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(regexp))
grammar.setGeneratesEpsilon(true);
return grammar;
}
-void GlushkovNFA::Visit(void* userData, const regexp::FormalRegExp& regexp) const
+void ToGrammarRightRGGlushkov::Visit(void* userData, const regexp::FormalRegExp& regexp) const
{
/*
grammar::Grammar* & out = *((grammar::Grammar**) userData);
@@ -105,14 +103,14 @@ void GlushkovNFA::Visit(void* userData, const regexp::FormalRegExp& regexp) cons
throw exception::AlibException("Glushkov: Converting FormalRegExp NYI"); // TODO
}
-void GlushkovNFA::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
+void ToGrammarRightRGGlushkov::Visit(void* userData, const regexp::UnboundedRegExp& regexp) const
{
grammar::Grammar* & out = *((grammar::Grammar**) userData);
out = new grammar::Grammar(this->convert(regexp));
}
-const GlushkovNFA GlushkovNFA::GLUSHKOV_NFA;
+const ToGrammarRightRGGlushkov ToGrammarRightRGGlushkov::TO_GRAMMAR_RIGHT_RG_GLUSHKOV;
-} /* namespace re2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.h b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
similarity index 68%
rename from alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.h
rename to alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
index 32de94e8b020907573114155fb9c1c8b33bea075..42a9cb9e82f76a6c94e63c5cd75a9763672e1957 100644
--- a/alib2algo/src/regexp/toGrammar/toRightRG/GlushkovNFA.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
@@ -1,12 +1,12 @@
/*
- * Glushkov.h
+ * ToGrammarRightRGGlushkov.h
*
* Created on: 11. 1. 2014
* Author: Tomas Pecka
*/
-#ifndef RE2RG_GLUSHKOVNFA_H_
-#define RE2RG_GLUSHKOVNFA_H_
+#ifndef TO_GRAMMAR_RIGHT_RG_GLUSHKOV_H_
+#define TO_GRAMMAR_RIGHT_RG_GLUSHKOV_H_
#include <grammar/Grammar.h>
#include <grammar/Regular/RightRG.h>
@@ -15,17 +15,15 @@
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
-namespace conversions
-{
+namespace regexp {
-namespace re2rg
-{
+namespace convert {
/**
* Converts regular expression to right regular grammar using Glushkov algorithm.
* Source: None yet.
*/
-class GlushkovNFA : public regexp::VisitableRegExpBase::const_visitor_type
+class ToGrammarRightRGGlushkov : public regexp::VisitableRegExpBase::const_visitor_type
{
public:
/**
@@ -42,11 +40,11 @@ private:
void Visit(void*, const regexp::FormalRegExp& regexp) const;
void Visit(void*, const regexp::UnboundedRegExp& regexp) const;
- static const GlushkovNFA GLUSHKOV_NFA;
+ static const ToGrammarRightRGGlushkov TO_GRAMMAR_RIGHT_RG_GLUSHKOV;
};
-} /* namespace re2rg */
+} /* namespace convert */
-} /* namespace conversions */
+} /* namespace regexp */
-#endif /* RE2RG_GLUSHKOVNFA_H_ */
+#endif /* TO_GRAMMAR_RIGHT_RG_GLUSHKOV_H_ */
diff --git a/alib2algo/src/regexp/generate/RandomRegExpFactory.cpp b/alib2algo/src/regexp/generate/RandomRegExpFactory.cpp
index 7dfd8eca9ecdbbcf29aa6bab8ef28d4dece83278..196802377d61ebe9fc9e4d690c0756b4090d4837 100644
--- a/alib2algo/src/regexp/generate/RandomRegExpFactory.cpp
+++ b/alib2algo/src/regexp/generate/RandomRegExpFactory.cpp
@@ -9,7 +9,9 @@
#include <algorithm>
-namespace generator {
+namespace regexp {
+
+namespace generate {
regexp::UnboundedRegExp RandomRegExpFactory::generateUnboundedRegExp( size_t leafNodes, size_t height, size_t alphabetSize ) {
srand( time( NULL ) );
@@ -142,4 +144,6 @@ const regexp::UnboundedRegExpElement* RandomRegExpFactory::SimpleUnboundedRegExp
}
}
-}
+} /* namespace generate */
+
+} /* namespace regexp */
diff --git a/alib2algo/src/regexp/generate/RandomRegExpFactory.h b/alib2algo/src/regexp/generate/RandomRegExpFactory.h
index 0459faf3acffa1f6d7308dd508a4fe17b6f92179..eaee929c6c09017ebf1921415077a29dc98fe290 100644
--- a/alib2algo/src/regexp/generate/RandomRegExpFactory.h
+++ b/alib2algo/src/regexp/generate/RandomRegExpFactory.h
@@ -15,7 +15,9 @@
#include <regexp/unbounded/UnboundedRegExp.h>
#include <regexp/unbounded/UnboundedRegExpElements.h>
-namespace generator {
+namespace regexp {
+
+namespace generate {
class RandomRegExpFactory {
public:
@@ -27,6 +29,8 @@ private:
static const regexp::UnboundedRegExpElement* SimpleUnboundedRegExpElement(size_t n, size_t h, const std::vector<const regexp::UnboundedRegExpElement*> & elems);
};
-}
+} /* namespace generate */
+
+} /* namespace regexp */
#endif /* RANDOM_REG_EXP_FACTORY_H_ */
diff --git a/alib2algo/src/regexp/properties/RegExpEmpty.cpp b/alib2algo/src/regexp/properties/RegExpEmpty.cpp
index 16247f9328df4c77308a87236084275b3f58f622..eae0d1262feea3bd2b7c561eda283fede9a3af34 100644
--- a/alib2algo/src/regexp/properties/RegExpEmpty.cpp
+++ b/alib2algo/src/regexp/properties/RegExpEmpty.cpp
@@ -7,8 +7,9 @@
#include "RegExpEmpty.h"
-namespace regexp
-{
+namespace regexp {
+
+namespace properties {
bool RegExpEmpty::languageIsEmpty(const regexp::RegExp& regexp)
{
@@ -157,4 +158,6 @@ void RegExpEmpty::Visit(void* data, const regexp::UnboundedRegExp& regexp) const
const RegExpEmpty RegExpEmpty::REG_EXP_EMPTY;
+} /* namespace properties */
+
} /* namespace regexp */
diff --git a/alib2algo/src/regexp/properties/RegExpEmpty.h b/alib2algo/src/regexp/properties/RegExpEmpty.h
index 8b2958e121a1cf60d0ee7035768d100262684711..d76fa5fac364d1b933b73f399832cf47fc14f20e 100644
--- a/alib2algo/src/regexp/properties/RegExpEmpty.h
+++ b/alib2algo/src/regexp/properties/RegExpEmpty.h
@@ -12,8 +12,9 @@
#include <regexp/formal/FormalRegExpElements.h>
#include <regexp/unbounded/UnboundedRegExpElements.h>
-namespace regexp
-{
+namespace regexp {
+
+namespace properties {
/**
* Determines whether regular expression is empty (regexp == \0)
@@ -48,6 +49,8 @@ private:
static const RegExpEmpty REG_EXP_EMPTY;
};
+} /* namespace properties */
+
} /* namespace regexp */
#endif /* REG_EXP_EMPTY_H_ */
diff --git a/alib2algo/src/regexp/properties/RegExpEpsilon.cpp b/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
index c697cbbdd16061eb579353d0eec35df5bbb9e96a..58c9ed6497bf7235d1c71695143cf1ab1004481f 100644
--- a/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
+++ b/alib2algo/src/regexp/properties/RegExpEpsilon.cpp
@@ -7,8 +7,9 @@
#include "RegExpEpsilon.h"
-namespace regexp
-{
+namespace regexp {
+
+namespace properties {
bool RegExpEpsilon::languageContainsEpsilon(const regexp::RegExp& regexp)
{
@@ -174,4 +175,6 @@ void RegExpEpsilon::Visit(void* data, const regexp::UnboundedRegExp& regexp) con
const RegExpEpsilon RegExpEpsilon::REG_EXP_EPSILON;
+} /* namespace properties */
+
} /* namespace regexp */
diff --git a/alib2algo/src/regexp/properties/RegExpEpsilon.h b/alib2algo/src/regexp/properties/RegExpEpsilon.h
index 4472068c2c856e87ecb974eedb962b284915b797..58d2518919684da699a1d26048048ac3d0e72198 100644
--- a/alib2algo/src/regexp/properties/RegExpEpsilon.h
+++ b/alib2algo/src/regexp/properties/RegExpEpsilon.h
@@ -12,8 +12,9 @@
#include <regexp/formal/FormalRegExpElements.h>
#include <regexp/unbounded/UnboundedRegExpElements.h>
-namespace regexp
-{
+namespace regexp {
+
+namespace properties {
/**
* Checks, whether regexp (or its subtree) describes epsilon (empty string).
@@ -53,6 +54,8 @@ private:
static const RegExpEpsilon REG_EXP_EPSILON;
};
+} /* namespace properties */
+
} /* namespace regexp */
#endif /* REG_EXP_EPSILON_H_ */
diff --git a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
index 95f668405c83e2e049b28433eabb50babf150b8a..053e0c5c8ca883e05bf61ab0647f3f18d40be569 100644
--- a/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
+++ b/alib2algo/src/regexp/simplify/RegExpOptimizeUnboundedPart.cxx
@@ -999,7 +999,7 @@ bool RegExpOptimize::V8( UnboundedRegExpConcatenation * const & node ) const
auto it2 = it;
advance( it2, - (int)concat->elements.size( ) );
- if( regexp::RegExpEpsilon::languageContainsEpsilon(*concat) &&
+ if( regexp::properties::RegExpEpsilon::languageContainsEpsilon(*concat) &&
distance( concat->elements.begin( ), concat->elements.end( )) == distance ( it2, node->elements.end( ) ) &&
equal( concat->elements.begin( ), concat->elements.end( ), it2, [] ( UnboundedRegExpElement const * const & a, UnboundedRegExpElement const * const & b ) -> bool { return *a == *b; } ) )
{
@@ -1025,7 +1025,7 @@ bool RegExpOptimize::V8( UnboundedRegExpConcatenation * const & node ) const
auto prev = std::prev( it );
- if( regexp::RegExpEpsilon::languageContainsEpsilon(*(iter->element)) && *( iter->element ) == **prev )
+ if( regexp::properties::RegExpEpsilon::languageContainsEpsilon(*(iter->element)) && *( iter->element ) == **prev )
{
delete * prev;
it = node->elements.erase( prev );
diff --git a/alib2algo/src/regexp/toAutomaton/GlushkovNFA.h b/alib2algo/src/regexp/toAutomaton/GlushkovNFA.h
deleted file mode 100644
index 1cb1c806b7aa9859135c1a9841ee8b22664fb6fe..0000000000000000000000000000000000000000
--- a/alib2algo/src/regexp/toAutomaton/GlushkovNFA.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * GlushkovNFA.h
- *
- * Created on: 11. 1. 2014
- * Author: Tomas Pecka
- */
-
-#ifndef FA2RE_GLUSHKOVNFA_H_
-#define FA2RE_GLUSHKOVNFA_H_
-
-#include <map>
-
-#include <automaton/FSM/NFA.h>
-#include <regexp/RegExp.h>
-#include <regexp/formal/FormalRegExp.h>
-#include <regexp/unbounded/UnboundedRegExp.h>
-
-namespace conversions {
-
-namespace re2fa {
-
-/**
- * Converts regular expression to finite automaton using Glushkov's NFA construction algorithm.
- * Source: Melichar 2.107
- */
-class GlushkovNFA : public regexp::VisitableRegExpBase::const_visitor_type
-{
-public:
- /**
- * Performs conversion.
- * @param re Original regular expression.
- * @return NFA equivalent to original regular expression.
- */
- static automaton::NFA convert(const regexp::RegExp& re);
-
- static automaton::NFA convert(const regexp::UnboundedRegExp& re);
- static automaton::NFA convert(const regexp::FormalRegExp& re);
-
-private:
- void Visit(void*, const regexp::FormalRegExp& regexp) const;
- void Visit(void*, const regexp::UnboundedRegExp& regexp) const;
-
- static const GlushkovNFA GLUSHKOV_NFA;
-};
-
-} /* namespace re2fa */
-
-} /* namespace conversions */
-
-#endif /* FA2RE_GLUSHKOV_H_ */
diff --git a/alib2algo/src/regexp/transform/RegExpDerivation.cpp b/alib2algo/src/regexp/transform/RegExpDerivation.cpp
index 089c19818401bd86bd998d7efe1791f56d5fdbea..cbf0f3a744251b1c9541e9cdca6735b6ef92a87f 100644
--- a/alib2algo/src/regexp/transform/RegExpDerivation.cpp
+++ b/alib2algo/src/regexp/transform/RegExpDerivation.cpp
@@ -97,7 +97,7 @@ void RegExpDerivation::Visit(void* userData, const regexp::FormalRegExpConcatena
delete leftDerivative;
delete rightElement;
- if(regexp::RegExpEpsilon::languageContainsEpsilon(concatenation.getLeftElement()))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(concatenation.getLeftElement()))
{
const regexp::FormalRegExpElement *alternation = out.second, *rightDerivative = nullptr;
static_cast<const regexp::FormalRegExpElement&>(concatenation.getRightElement()).Accept(userData, *this);
@@ -186,7 +186,7 @@ void RegExpDerivation::Visit(void* userData, const regexp::UnboundedRegExpConcat
ret->appendElement(std::move(*concat));
delete concat;
- if(regexp::RegExpEpsilon::languageContainsEpsilon(**child))
+ if(regexp::properties::RegExpEpsilon::languageContainsEpsilon(**child))
continue; // this IF construct is intentional "to match algorithm"
break;
}
diff --git a/alib2algo/src/string/compare/CyclicStringCompare.cpp b/alib2algo/src/string/compare/CyclicStringCompare.cpp
index 0e8fc8b879a6c37df39f19602558af4bf8d20191..0e33dfbe2a59f8bc0255e2ee2d8f28346597dc13 100644
--- a/alib2algo/src/string/compare/CyclicStringCompare.cpp
+++ b/alib2algo/src/string/compare/CyclicStringCompare.cpp
@@ -6,8 +6,10 @@
#include "CyclicStringCompare.h"
+namespace string {
+
namespace compare {
-
+
bool CyclicStringCompare::equals(const string::LinearString& u, const string::LinearString& v) {
int n = (int)u.getContent().size();
int i = -1, j = -1, k;
@@ -39,4 +41,6 @@ int CyclicStringCompare::compare(const string::LinearString& u, const string::Li
return last ? 1 : - 1;
}
-}
+} /* namespace compare */
+
+} /* namespace string */
diff --git a/alib2algo/src/string/compare/CyclicStringCompare.h b/alib2algo/src/string/compare/CyclicStringCompare.h
index 18e062432185332ba40c38737496ee25aea62d60..267a791376918e9f287bb714706e58e1163ce2ca 100644
--- a/alib2algo/src/string/compare/CyclicStringCompare.h
+++ b/alib2algo/src/string/compare/CyclicStringCompare.h
@@ -10,6 +10,8 @@
#include "string/LinearString.h"
+namespace string {
+
namespace compare {
class CyclicStringCompare {
@@ -19,6 +21,8 @@ public:
};
-}
+} /* namespace compare */
+
+} /* namespace string */
#endif /* CYCLIC_STRING_COMPARE_H_ */
diff --git a/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp b/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
index 80633bd7a3285a84c8f0cba8bacb24c620b9c5e3..ebf7a14df0cd2755058c0f973ce4c4e695c6cac5 100644
--- a/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
+++ b/alib2algo/test-src/grammar/toGrammar/rg2rgTest.cpp
@@ -1,8 +1,8 @@
#include <list>
#include "rg2rgTest.h"
-#include "grammar/toGrammar/RightToLeftRegularGrammar.h"
-#include "grammar/toGrammar/LeftToRightRegularGrammar.h"
+#include "grammar/convert/ToGrammarLeftRG.h"
+#include "grammar/convert/ToGrammarRightRG.h"
#define CPPUNIT_IMPLY(x, y) CPPUNIT_ASSERT(!(x) || (y))
@@ -27,7 +27,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"));
- grammar::LeftRG lrGrammar = conversions::rg2rg::RightToLeftRegularGrammar::convert(rrGrammar);
+ grammar::LeftRG lrGrammar = grammar::convert::ToGrammarLeftRG::convert(rrGrammar);
grammar::LeftRG lrGrammarRef(alphabet::symbolFrom(4));
@@ -58,7 +58,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")));
- grammar::RightRG rrGrammar = conversions::rg2rg::LeftToRightRegularGrammar::convert(lrGrammar);
+ grammar::RightRG rrGrammar = grammar::convert::ToGrammarRightRG::convert(lrGrammar);
grammar::RightRG rrGrammarRef(alphabet::symbolFrom(5));
diff --git a/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp b/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
index 43ccaad97463e3e49c8dd9a1bbf7c8ab97d95aac..bf5dfdb0d2eb2d29e33bed488af62e7c972d2633 100644
--- a/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
+++ b/alib2algo/test-src/regexp/properties/RegExpEmptyTest.cpp
@@ -21,7 +21,7 @@ void RegExpEmptyTest::testRegExpEmpty() {
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(regexp::RegExpEmpty::languageIsEmpty(re));
+ CPPUNIT_ASSERT(regexp::properties::RegExpEmpty::languageIsEmpty(re));
}
{
std::string input = "(#E + a ) + ( #0 a + (b ( #0 (a*) ) ) )";
@@ -29,6 +29,6 @@ void RegExpEmptyTest::testRegExpEmpty() {
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(! regexp::RegExpEmpty::languageIsEmpty(re));
+ CPPUNIT_ASSERT(! regexp::properties::RegExpEmpty::languageIsEmpty(re));
}
}
diff --git a/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp b/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
index d7406a30cb47d468908094f34701b4d9bee914b2..05c2af2065968df9099cdaed0aa53ef92ca67c56 100644
--- a/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
+++ b/alib2algo/test-src/regexp/properties/RegExpEpsilonTest.cpp
@@ -20,54 +20,54 @@ void RegExpEpsilonTest::testRegExpEpsilon() {
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "( a* )( a* )";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "a + #0";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(! regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "#E + a #E + a*";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "a* a*";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "a s d #E + #E #0";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(! regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
{
std::string input = "a + #0";
std::stringstream inputs(input);
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp re = parser.parseValue();
- CPPUNIT_ASSERT(! regexp::RegExpEpsilon::languageContainsEpsilon(re));
- }
+ CPPUNIT_ASSERT(! regexp::properties::RegExpEpsilon::languageContainsEpsilon(re));
+ }
}
diff --git a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
index d24b039525c921e57b097cd85f1f240108bbcc29..8be6ccb6e2129abe6506e73d73f056e55fe63c2f 100644
--- a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
+++ b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
@@ -1,9 +1,9 @@
#include <list>
#include "re2faTest.h"
-#include "regexp/toAutomaton/BrzozowskiDerivation.h"
-#include "regexp/toAutomaton/GlushkovNFA.h"
-#include "regexp/toAutomaton/Thompson.h"
+#include "regexp/convert/ToAutomatonDerivation.h"
+#include "regexp/convert/ToAutomatonGlushkov.h"
+#include "regexp/convert/ToAutomatonThompson.h"
#include "automaton/convert/ToRegExpAlgebraic.h"
#include "automaton/determinize/nfa/NFADeterminizer.h"
#include "automaton/simplify/Minimize.h"
@@ -31,11 +31,11 @@ void re2faTest::testThompson() {
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp regexp1( parser.parseValue() );
- automaton::Automaton enfa1 = conversions::re2fa::Thompson::convert(regexp1);
+ automaton::Automaton enfa1 = regexp::convert::ToAutomatonThompson::convert(regexp1);
regexp::RegExp regexp2( automaton::convert::ToRegExpAlgebraic::convert(enfa1) );
- automaton::Automaton enfa2 = conversions::re2fa::Thompson::convert(regexp2);
+ automaton::Automaton enfa2 = regexp::convert::ToAutomatonThompson::convert(regexp2);
automaton::Automaton nfa1 = automaton::simplify::EpsilonRemover::remove(enfa1);
automaton::Automaton nfa2 = automaton::simplify::EpsilonRemover::remove(enfa2);
@@ -56,13 +56,11 @@ void re2faTest::testGlushkov() {
regexp::RegExpFromStringParser parser(inputs);
regexp::UnboundedRegExp regexp1( static_cast<const regexp::UnboundedRegExp &>( parser.parseValue().getData() ) );
- conversions::re2fa::GlushkovNFA glushkov1;
- automaton::NFA nfa1 = glushkov1.convert(regexp1);
+ automaton::NFA nfa1 = regexp::convert::ToAutomatonGlushkov::convert(regexp1);
regexp::UnboundedRegExp regexp2( static_cast<const regexp::UnboundedRegExp &>( automaton::convert::ToRegExpAlgebraic::convert(nfa1) ) );
- conversions::re2fa::GlushkovNFA glushkov2;
- automaton::NFA nfa2 = glushkov2.convert(regexp2);
+ automaton::NFA nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
automaton::DFA dfa1 = determinize::NFADeterminizer::determinize(nfa1);
automaton::DFA dfa2 = determinize::NFADeterminizer::determinize(nfa2);
@@ -80,11 +78,11 @@ void re2faTest::testBrzozowski() {
regexp::RegExpFromStringParser parser(inputs);
regexp::RegExp regexp1( parser.parseValue() );
- automaton::Automaton nfa1 = conversions::re2fa::BrzozowskiDerivation::convert(regexp1);
+ automaton::Automaton nfa1 = regexp::convert::ToAutomatonDerivation::convert(regexp1);
regexp::RegExp regexp2( automaton::convert::ToRegExpAlgebraic::convert(static_cast<const automaton::NFA&>(nfa1.getData())) );
- automaton::Automaton nfa2 = conversions::re2fa::BrzozowskiDerivation::convert(regexp2);
+ automaton::Automaton nfa2 = regexp::convert::ToAutomatonDerivation::convert(regexp2);
automaton::DFA mdfa1_1 = determinize::NFADeterminizer::determinize(static_cast<const automaton::NFA&>(nfa1.getData()));
automaton::DFA mdfa1_2 = automaton::simplify::Minimize::minimize(mdfa1_1);
diff --git a/alib2algo/test-src/string/compare/compareTest.cpp b/alib2algo/test-src/string/compare/compareTest.cpp
index 79481b73b3c73d7197fc5e2e42a01c89c2cf1d83..d75ef51ca8a3414a4b7b5eea6e901d5e1c099851 100644
--- a/alib2algo/test-src/string/compare/compareTest.cpp
+++ b/alib2algo/test-src/string/compare/compareTest.cpp
@@ -15,19 +15,19 @@ void compareTest::tearDown() {
}
void compareTest::testCyclicStringCompareBoolean() {
- string::LinearString str1("alfa");
- string::LinearString str2("aalf");
- str2.addSymbolsToAlphabet(str1.getAlphabet());
- str1.addSymbolsToAlphabet(str2.getAlphabet());
-
- CPPUNIT_ASSERT(compare::CyclicStringCompare::equals(str1, str2));
+ string::LinearString str1("alfa");
+ string::LinearString str2("aalf");
+ str2.addSymbolsToAlphabet(str1.getAlphabet());
+ str1.addSymbolsToAlphabet(str2.getAlphabet());
+
+ CPPUNIT_ASSERT(string::compare::CyclicStringCompare::equals(str1, str2));
}
void compareTest::testCyclicStringCompareInt() {
- string::LinearString str1("alfa");
- string::LinearString str2("aalf");
- str2.addSymbolsToAlphabet(str1.getAlphabet());
- str1.addSymbolsToAlphabet(str2.getAlphabet());
-
- CPPUNIT_ASSERT(compare::CyclicStringCompare::compare(str1, str2) == 0);
+ string::LinearString str1("alfa");
+ string::LinearString str2("aalf");
+ str2.addSymbolsToAlphabet(str1.getAlphabet());
+ str1.addSymbolsToAlphabet(str2.getAlphabet());
+
+ CPPUNIT_ASSERT(string::compare::CyclicStringCompare::compare(str1, str2) == 0);
}
diff --git a/arand2/src/arand.cpp b/arand2/src/arand.cpp
index 81bc884f1e1468e047fcb89e51fb4ebb4c360e85..316e99a031900f7404b8576b6f79940a6cfa2b56 100644
--- a/arand2/src/arand.cpp
+++ b/arand2/src/arand.cpp
@@ -139,7 +139,7 @@ int main(int argc, char* argv[])
return 1;
}
- regexp::UnboundedRegExp res = generator::RandomRegExpFactory::generateUnboundedRegExp(leafNodes, height, alphabetSize );
+ regexp::UnboundedRegExp res = regexp::generate::RandomRegExpFactory::generateUnboundedRegExp(leafNodes, height, alphabetSize );
alib::DataFactory::toStdout(res);
}