From 05ae3b4622ae57598d4ddbf567cc7d2361e8ba6a Mon Sep 17 00:00:00 2001
From: Jan Travnicek <Jan.Travnicek@fit.cvut.cz>
Date: Mon, 11 Sep 2017 08:33:33 +0200
Subject: [PATCH] use cli in conversions
---
aconversions2/makefile.conf | 6 +-
aconversions2/src/ConversionHandler.cpp | 344 ++++--------------
aconversions2/src/ConversionHandler.h | 42 +--
aconversions2/src/aconversion.cpp | 31 +-
.../src/automaton/convert/ToGrammarLeftRG.cpp | 9 +-
.../src/automaton/convert/ToGrammarLeftRG.h | 8 +-
.../automaton/convert/ToGrammarRightRG.cpp | 9 +-
.../src/automaton/convert/ToGrammarRightRG.h | 8 +-
.../convert/ToPostfixPushdownAutomaton.cpp | 8 +-
.../convert/ToPostfixPushdownAutomaton.h | 7 +-
.../automaton/convert/ToRegExpAlgebraic.cpp | 15 +-
.../src/automaton/convert/ToRegExpAlgebraic.h | 8 +-
.../convert/ToRegExpStateElimination.cpp | 24 +-
.../convert/ToRegExpStateElimination.h | 8 +-
alib2algo/src/grammar/convert/ToAutomaton.cpp | 14 +-
alib2algo/src/grammar/convert/ToAutomaton.h | 8 +-
.../grammar/convert/ToAutomatonBottomUp.cpp | 8 +-
.../src/grammar/convert/ToAutomatonBottomUp.h | 7 +-
.../src/grammar/convert/ToRegExpAlgebraic.cpp | 8 +-
.../src/grammar/convert/ToRegExpAlgebraic.h | 9 +-
.../regexp/convert/ToAutomatonDerivation.cpp | 8 +-
.../regexp/convert/ToAutomatonDerivation.h | 7 +-
.../regexp/convert/ToAutomatonGlushkov.cpp | 10 +-
.../src/regexp/convert/ToAutomatonGlushkov.h | 6 +-
.../regexp/convert/ToAutomatonThompson.cpp | 9 +-
.../src/regexp/convert/ToAutomatonThompson.h | 7 +-
.../convert/ToGrammarRightRGDerivation.cpp | 8 +-
.../convert/ToGrammarRightRGDerivation.h | 7 +-
.../convert/ToGrammarRightRGGlushkov.cpp | 9 +-
.../regexp/convert/ToGrammarRightRGGlushkov.h | 8 +-
.../ToPostfixPushdownAutomatonGlushkov.cpp | 9 +-
.../ToPostfixPushdownAutomatonGlushkov.h | 6 +-
...oPostfixPushdownAutomatonGlushkovNaive.cpp | 8 +-
.../ToPostfixPushdownAutomatonGlushkovNaive.h | 6 +-
.../test-src/regexp/toAutomaton/re2faTest.cpp | 10 +-
35 files changed, 182 insertions(+), 517 deletions(-)
diff --git a/aconversions2/makefile.conf b/aconversions2/makefile.conf
index d4df0fe977..b02ee8d1f9 100644
--- a/aconversions2/makefile.conf
+++ b/aconversions2/makefile.conf
@@ -1,4 +1,4 @@
EXECUTABLE:=aconversions2
-LINK_PATHS=../alib2elgo/ ../alib2algo/ ../alib2data/ ../alib2common/ ../alib2std/
-LINK_LIBRARIES=alib2elgo alib2algo alib2data alib2common alib2std xml2
-INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2elgo/src/ \$$(SOURCES_BASE_DIR)/../../alib2algo/src/ \$$(SOURCES_BASE_DIR)/../../alib2data/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/
+LINK_PATHS=../alib2cli/ ../alib2elgo/ ../alib2algo/ ../alib2data/ ../alib2common/ ../alib2std/
+LINK_LIBRARIES=alib2cli alib2elgo alib2algo alib2data alib2common alib2std xml2
+INCLUDE_PATHS=\$$(SOURCES_BASE_DIR)/../../alib2cli/src/ \$$(SOURCES_BASE_DIR)/../../alib2common/src/ \$$(SOURCES_BASE_DIR)/../../alib2std/src/ /usr/include/libxml2/
diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index b799488ec1..aaa2bf951d 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -5,174 +5,108 @@
* Author: Tomas Pecka
*/
-#include <measure>
#include "ConversionHandler.h"
-
-#include "automaton/convert/ToRegExpStateElimination.h"
-#include "automaton/convert/ToRegExpAlgebraic.h"
-#include "automaton/convert/ToGrammarLeftRG.h"
-#include "automaton/convert/ToGrammarRightRG.h"
-#include "automaton/convert/ToPostfixPushdownAutomaton.h"
-
-#include "regexp/convert/ToAutomatonGlushkov.h"
-#include "regexp/convert/ToAutomatonThompson.h"
-#include "regexp/convert/ToAutomatonDerivation.h"
-
-#include "grammar/convert/ToAutomaton.h"
-#include "grammar/convert/ToAutomatonBottomUp.h"
-#include "grammar/convert/ToRegExpAlgebraic.h"
-
-#include "regexp/convert/ToGrammarRightRGGlushkov.h"
-#include "regexp/convert/ToGrammarRightRGDerivation.h"
-
-#include "rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.h"
-#include "rte/convert/ToPostfixPushdownAutomatonGlushkov.h"
-
-#include <factory/XmlDataFactory.hpp>
#include <exception/CommonException.h>
-ConversionHandler::ConversionHandler( ext::deque<sax::Token> && tokens, const std::string & target, const std::string & algorithm ) :
- m_tokens( std::move( tokens ) ),
- m_source( parseFormalismFromTokens( ) ),
+ConversionHandler::ConversionHandler( const std::string & inputType, const std::string & target, const std::string & algorithm ) :
+ m_source( parseFormalismFromType( inputType ) ),
m_target( parseFormalismFromString( target ) ),
m_algorithm( parseAlgorithmFromString( algorithm ) )
{
}
-void ConversionHandler::convert ( void ) {
+std::string ConversionHandler::convert ( ) {
if ( m_source == FINITE_AUTOMATON )
- convertFA ( );
+ return convertFA ( );
else if ( m_source == REGULAR_EXPRESSION )
- convertRE ( );
+ return convertRE ( );
else if ( m_source == REGULAR_GRAMMAR )
- convertRG ( );
+ return convertRG ( );
else if ( m_source == PUSHDOWN_AUTOMATON )
- convertPDA ( );
+ return convertPDA ( );
else if ( m_source == CONTEXTFREE_GRAMMAR )
- convertCFG ( );
+ return convertCFG ( );
else if ( m_source == REGULAR_TREE_EXPRESSION )
- convertRTE ( );
+ return convertRTE ( );
else
throw exception::CommonException( "ConversionHandler: Unknown source formalism." );
}
// ----------------------------------------------------------------------------
-void ConversionHandler::convertFA ( void ) {
+std::string ConversionHandler::convertFA ( ) {
if ( m_target == REGULAR_EXPRESSION )
- convertFAtoRE ( );
+ return convertFAtoRE ( );
else if ( m_target == REGULAR_GRAMMAR )
- convertFAtoRG ( );
+ return convertFAtoRG ( );
else
throw exception::CommonException( "ConversionHandler: Unknown target formalism." );
}
-void ConversionHandler::convertRE ( void ) {
+std::string ConversionHandler::convertRE ( ) {
if ( m_target == FINITE_AUTOMATON )
- convertREtoFA ( );
+ return convertREtoFA ( );
else if ( m_target == REGULAR_GRAMMAR )
- convertREtoRG ( );
+ return convertREtoRG ( );
else
throw exception::CommonException( "ConversionHandler: Invalid target formalism." );
}
-void ConversionHandler::convertRG ( void ) {
+std::string ConversionHandler::convertRG ( ) {
if ( m_target == FINITE_AUTOMATON )
- convertRGtoFA ( );
+ return convertRGtoFA ( );
else if ( m_target == REGULAR_EXPRESSION )
- convertRGtoRE ( );
+ return convertRGtoRE ( );
else
throw exception::CommonException( "ConversionHandler: Invalid target formalism." );
}
-void ConversionHandler::convertPDA ( void ) {
+std::string ConversionHandler::convertPDA ( ) {
throw exception::CommonException ( "ConversionHandler: Invalid source formalism." );
}
-void ConversionHandler::convertCFG ( void ) {
+std::string ConversionHandler::convertCFG ( ) {
if ( m_target == PUSHDOWN_AUTOMATON )
- convertCFGtoPDA ( );
+ return convertCFGtoPDA ( );
else
throw exception::CommonException ( "ConversionHandler: Invalid target formalism." );
}
-void ConversionHandler::convertRTE ( void ) {
+std::string ConversionHandler::convertRTE ( ) {
if ( m_target == PUSHDOWN_AUTOMATON )
- convertRTEtoPDA ( );
+ return convertRTEtoPDA ( );
else
throw exception::CommonException( "ConversionHandler: Invalid target formalism." );
}
-void ConversionHandler::convertFTA ( void ) {
+std::string ConversionHandler::convertFTA ( ) {
if ( m_target == PUSHDOWN_AUTOMATON )
- convertFTAtoPDA ( );
+ return convertFTAtoPDA ( );
else
throw exception::CommonException( "ConversionHandler: Invalid target formalism." );
}
// ----------------------------------------------------------------------------
-void ConversionHandler::convertFAtoRE ( void ) {
- const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertFAtoRE ( ) {
switch ( m_algorithm ) {
- case BRZOZOWSKI_ALGEBRAIC: {
- regexp::RegExp regexp = automaton::convert::ToRegExpAlgebraic::convert ( automaton );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( regexp );
- break;
- }
-
+ case BRZOZOWSKI_ALGEBRAIC:
+ return "execute automaton::convert::ToRegExpAlgebraic $input > $output";
case STATE_ELIMINATION:
- case DEFAULT: {
- regexp::RegExp regexp = automaton::convert::ToRegExpStateElimination::convert ( automaton );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( regexp );
- break;
- }
-
+ case DEFAULT:
+ return "execute automaton::convert::ToRegExpStateElimination $input > $output";
default:
throw exception::CommonException ( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertFAtoRG ( void ) {
- const automaton::Automaton fsm = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertFAtoRG ( ) {
switch ( m_algorithm ) {
- case INCOMING_TRANSITIONS: {
- grammar::LeftRG < > grammar = automaton::convert::ToGrammarLeftRG::convert ( fsm );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( grammar );
- break;
- }
-
+ case INCOMING_TRANSITIONS:
+ return "execute automaton::convert::ToGrammarLeftRG $input > $output";
case OUTGOING_TRANSITIONS:
- case DEFAULT: {
- grammar::RightRG < > grammar = automaton::convert::ToGrammarRightRG::convert ( fsm );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( grammar );
- break;
- }
-
+ case DEFAULT:
+ return "execute automaton::convert::ToGrammarRightRG $input > $output";
default:
throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
@@ -180,77 +114,27 @@ void ConversionHandler::convertFAtoRG ( void ) {
// ----------------------------------------------------------------------------
-void ConversionHandler::convertREtoFA ( void ) {
- const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertREtoFA ( ) {
switch ( m_algorithm ) {
- case BRZOZOWSKI_DERIVATION: {
- automaton::DFA<> automaton = regexp::convert::ToAutomatonDerivation::convert ( regexp );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
- case THOMPSON_NFA: {
- automaton::EpsilonNFA < > automaton = regexp::convert::ToAutomatonThompson::convert ( regexp );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
+ case BRZOZOWSKI_DERIVATION:
+ return "execute regexp::convert::ToAutomatonDerivation $input > $output";
+ case THOMPSON_NFA:
+ return "execute regexp::convert::ToAutomatonThompson $input > $output";
case GLUSHKOV_NFA:
- case DEFAULT: {
- automaton::NFA < > automaton = regexp::convert::ToAutomatonGlushkov::convert ( regexp );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
+ case DEFAULT:
+ return "execute regexp::convert::ToAutomatonGlushkov $input > $output";
default:
throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertREtoRG ( void ) {
- const regexp::RegExp regexp = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertREtoRG ( ) {
switch ( m_algorithm ) {
- case BRZOZOWSKI_DERIVATION: {
- grammar::RightRG < > grammar = regexp::convert::ToGrammarRightRGDerivation::convert ( regexp );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( grammar );
- break;
- }
-
+ case BRZOZOWSKI_DERIVATION:
+ return "execute regexp::convert::ToGrammarRightRGDerivation $input > $output";
case GLUSHKOV_NFA:
- case DEFAULT: {
- grammar::RightRG < > grammar = regexp::convert::ToGrammarRightRGGlushkov::convert ( regexp );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( grammar );
- break;
- }
-
+ case DEFAULT:
+ return "execute regexp::convert::ToGrammarRightRGGlushkov $input > $output";
default:
throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
@@ -258,133 +142,53 @@ void ConversionHandler::convertREtoRG ( void ) {
// ----------------------------------------------------------------------------
-void ConversionHandler::convertRGtoFA( void ) {
- const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens (std::move(m_tokens));
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertRGtoFA( ) {
switch ( m_algorithm ) {
- case DEFAULT: {
- automaton::Automaton automaton = grammar::convert::ToAutomaton::convert ( grammar );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
+ case DEFAULT:
+ return "execute grammar::convert::ToAutomaton $input > $output";
default:
throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertRGtoRE ( void ) {
- const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertRGtoRE ( ) {
switch ( m_algorithm ) {
case BRZOZOWSKI_ALGEBRAIC:
- case DEFAULT: {
- regexp::RegExp regexp = grammar::convert::ToRegExpAlgebraic::convert ( grammar );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( regexp );
- break;
- }
-
+ case DEFAULT:
+ return "execute grammar::convert::ToRegExpAlgebraic $input > $output";
default:
throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertCFGtoPDA ( void ) {
- const grammar::Grammar grammar = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertCFGtoPDA ( ) {
switch ( m_algorithm ) {
- case TOP_DOWN: {
- automaton::Automaton automaton = grammar::convert::ToAutomaton::convert ( grammar );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
- case BOTTOM_UP: {
- automaton::Automaton automaton = grammar::convert::ToAutomatonBottomUp::convert ( grammar );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
+ case TOP_DOWN:
+ return "execute grammar::convert::ToAutomaton $input > $output";
+ case BOTTOM_UP:
+ return "execute grammar::convert::ToAutomatonBottomUp $input > $output";
default:
throw exception::CommonException ( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertRTEtoPDA ( void ) {
- const rte::RTE rte = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertRTEtoPDA ( ) {
switch ( m_algorithm ) {
- case GLUSHKOV_RTE_NAIVE: {
- automaton::NPDA < > automaton = rte::convert::ToPostfixPushdownAutomatonGlushkovNaive::convert ( rte );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
- case GLUSHKOV_RTE: {
- automaton::Automaton automaton = rte::convert::ToPostfixPushdownAutomatonGlushkov::convert ( rte );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( automaton );
- break;
- }
-
+ case GLUSHKOV_RTE_NAIVE:
+ return "execute rte::convert::ToPostfixPushdownAutomatonGlushkovNaive $input > $output";
+ case GLUSHKOV_RTE:
+ return "execute rte::convert::ToPostfixPushdownAutomatonGlushkov $input > $output";
default:
throw exception::CommonException ( "ConversionHandler: Invalid algorithm." );
}
}
-void ConversionHandler::convertFTAtoPDA() {
- const automaton::Automaton automaton = alib::XmlDataFactory::fromTokens ( std::move ( m_tokens ) );
-
- measurements::end ( );
- measurements::start ( "Algorithm", measurements::Type::MAIN );
-
+std::string ConversionHandler::convertFTAtoPDA ( ) {
switch ( m_algorithm ) {
- case DEFAULT: {
- automaton::Automaton result = automaton::convert::ToPostfixPushdownAutomaton::convert ( automaton );
-
- measurements::end ( );
- measurements::start ( "Output write", measurements::Type::AUXILIARY );
-
- alib::XmlDataFactory::toStdout ( result );
- break;
- }
-
- default:
- throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
+ case DEFAULT:
+ return "execute automaton::convert::ToPostfixPushdownAutomaton $input > $output";
+ default:
+ throw exception::CommonException( "ConversionHandler: Invalid algorithm." );
}
}
@@ -406,20 +210,20 @@ ConversionHandler::TFormalism ConversionHandler::parseFormalismFromString ( cons
throw exception::CommonException ( "ConversionHandler: Unknown target type." );
}
-ConversionHandler::TFormalism ConversionHandler::parseFormalismFromTokens ( void ) const {
- if ( alib::XmlDataFactory::first < automaton::Automaton > ( m_tokens ) )
+ConversionHandler::TFormalism ConversionHandler::parseFormalismFromType ( const std::string & type ) const {
+ if ( type.find ( "automaton::" ) == 0 )
return FINITE_AUTOMATON;
- if ( alib::XmlDataFactory::first < regexp::RegExp > ( m_tokens ) )
+ if ( type.find ( "regexp::" ) == 0 )
return REGULAR_EXPRESSION;
- if ( alib::XmlDataFactory::first < grammar::CFG < > > ( m_tokens ) )
+ if ( type.find ( "grammar::CFG" ) == 0 )
return CONTEXTFREE_GRAMMAR;
- if ( alib::XmlDataFactory::first < grammar::Grammar > ( m_tokens ) )
+ if ( type.find ( "grammar::" ) == 0 )
return REGULAR_GRAMMAR;
- if ( alib::XmlDataFactory::first < rte::RTE > ( m_tokens ) )
+ if ( type.find ( "rte::" ) == 0 )
return REGULAR_TREE_EXPRESSION;
throw exception::CommonException ( "ConversionHandler: Invalid input formalism." );
diff --git a/aconversions2/src/ConversionHandler.h b/aconversions2/src/ConversionHandler.h
index 5d9ae39fd9..c591a9cd01 100644
--- a/aconversions2/src/ConversionHandler.h
+++ b/aconversions2/src/ConversionHandler.h
@@ -8,8 +8,7 @@
#ifndef ALGORITHMCHOOSER_H_
#define ALGORITHMCHOOSER_H_
-#include <deque>
-#include <sax/Token.h>
+#include <string>
/**
* Wraps all conversions.
@@ -44,38 +43,37 @@ public:
FINITE_TREE_AUTOMATON, REGULAR_TREE_EXPRESSION,
};
- ConversionHandler ( ext::deque < sax::Token > && tokens, const std::string & target, const std::string & algorithm );
- void convert ( void );
+ ConversionHandler ( const std::string & tokens, const std::string & target, const std::string & algorithm );
+ std::string convert ( );
private:
TFormalism parseFormalismFromString ( const std::string & _target ) const;
- TFormalism parseFormalismFromTokens ( void ) const;
+ TFormalism parseFormalismFromType ( const std::string & type ) const;
TAlgorithm parseAlgorithmFromString ( const std::string & _algorithm ) const;
- void convertFA ( void );
- void convertFAtoRE ( void );
- void convertFAtoRG ( void );
+ std::string convertFA ( );
+ std::string convertFAtoRE ( );
+ std::string convertFAtoRG ( );
- void convertRE ( void );
- void convertREtoFA ( void );
- void convertREtoRG ( void );
+ std::string convertRE ( );
+ std::string convertREtoFA ( );
+ std::string convertREtoRG ( );
- void convertRG ( void );
- void convertRGtoFA ( void );
- void convertRGtoRE ( void );
+ std::string convertRG ( );
+ std::string convertRGtoFA ( );
+ std::string convertRGtoRE ( );
- void convertPDA ( void );
+ std::string convertPDA ( );
- void convertCFG ( void );
- void convertCFGtoPDA ( void );
+ std::string convertCFG ( );
+ std::string convertCFGtoPDA ( );
- void convertRTE ( void );
- void convertRTEtoPDA ( void );
+ std::string convertRTE ( );
+ std::string convertRTEtoPDA ( );
- void convertFTA ( void );
- void convertFTAtoPDA ( void );
+ std::string convertFTA ( );
+ std::string convertFTAtoPDA ( );
- ext::deque < sax::Token > m_tokens;
TFormalism m_source, m_target;
TAlgorithm m_algorithm;
};
diff --git a/aconversions2/src/aconversion.cpp b/aconversions2/src/aconversion.cpp
index 07e44cdc09..0f0dd9fe9b 100644
--- a/aconversions2/src/aconversion.cpp
+++ b/aconversions2/src/aconversion.cpp
@@ -8,10 +8,10 @@
#include <tclap/CmdLine.h>
#include <global/GlobalData.h>
#include <measure>
-#include <sax/FromXMLParserHelper.h>
-#include <factory/XmlDataFactory.hpp>
#include <exception/CommonException.h>
+#include <lexer/Lexer.h>
+#include <parser/Parser.h>
#include "ConversionHandler.h"
@@ -53,16 +53,33 @@ int main ( int argc, char * argv[] ) {
if ( measure.isSet ( ) )
common::GlobalData::measure = true;
+ cli::Environment environment;
+ environment.setBinding ( "stdin", input.getValue ( ) );
+ environment.setBinding ( "stdout", "-" );
+
measurements::start ( "Overal", measurements::Type::OVERALL );
measurements::start ( "Input read", measurements::Type::AUXILIARY );
- ext::deque < sax::Token > inputTokens;
-
- ConversionHandler conv( sax::FromXMLParserHelper::parseInput(input), target.getValue(), algorithm.getValue() );
- conv.convert( );
+ cli::Parser parser ( cli::Lexer ( "execute <#stdin > $input" ) );
+ parser.parse ( )->run ( environment );
+ std::string inputType = environment.getVariable ( "input" )->getReturnType ( );
measurements::end ( );
- measurements::end ( );
+ measurements::start ( "Algorithm", measurements::Type::MAIN );
+
+ ConversionHandler conv( inputType, target.getValue(), algorithm.getValue() );
+ std::string convertString = conv.convert( );
+ parser = cli::Parser ( cli::Lexer ( convertString ) );
+ parser.parse ( )->run ( environment );
+
+ measurements::end();
+ measurements::start("Output write", measurements::Type::AUXILIARY);
+
+ parser = cli::Parser ( cli::Lexer ( "execute $output >#stdout" ) );
+ parser.parse ( )->run ( environment );
+
+ measurements::end();
+ measurements::end();
if ( measure.getValue ( ) ) ext::cmeasure << measurements::results ( ) << std::endl;
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
index 4c4d1d1d00..511c03ec2e 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.cpp
@@ -16,10 +16,6 @@ namespace automaton {
namespace convert {
-grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::Automaton& automaton) {
- return dispatch(automaton.getData());
-}
-
grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
// step 2
@@ -65,8 +61,6 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::NFA < > & automato
return grammar;
}
-auto ToGrammarLeftRGNFA = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, automaton::NFA < > >(ToGrammarLeftRG::convert);
-
grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
// step 2
@@ -110,7 +104,8 @@ grammar::LeftRG < > ToGrammarLeftRG::convert(const automaton::DFA<>& automaton)
return grammar;
}
-auto ToGrammarLeftRGDFA = registration::OverloadRegister < ToGrammarLeftRG, grammar::LeftRG < >, automaton::DFA < > >( ToGrammarLeftRG::convert );
+auto ToGrammarLeftRGNFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::NFA < > & > ( ToGrammarLeftRG::convert );
+auto ToGrammarLeftRGDFA = registration::AbstractRegister < ToGrammarLeftRG, grammar::LeftRG < >, const automaton::DFA < > & > ( ToGrammarLeftRG::convert );
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
index 057de30a6f..bd95158ee6 100644
--- a/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarLeftRG.h
@@ -8,14 +8,10 @@
#ifndef __TO_GRAMMAR_LEFT_RG_H__
#define __TO_GRAMMAR_LEFT_RG_H__
-#include <core/multipleDispatch.hpp>
-
#include <grammar/Regular/LeftRG.h>
#include <automaton/FSM/NFA.h>
#include <automaton/FSM/DFA.h>
-#include <automaton/Automaton.h>
-
namespace automaton {
namespace convert {
@@ -24,14 +20,12 @@ namespace convert {
* Finite automaton to right regular grammar converter.
* Source: My own :)
*/
-class ToGrammarLeftRG : public alib::SingleDispatch<ToGrammarLeftRG, grammar::LeftRG < >, const automaton::AutomatonBase &> {
+class ToGrammarLeftRG {
public:
/**
* Performs conversion.
* @return left regular grammar equivalent to source automaton.
*/
- static grammar::LeftRG < > convert(const automaton::Automaton& automaton);
-
static grammar::LeftRG < > convert(const automaton::NFA < > & automaton);
static grammar::LeftRG < > convert(const automaton::DFA<>& automaton);
};
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
index 0c17f756b8..b4acef5b64 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.cpp
@@ -13,10 +13,6 @@ namespace automaton {
namespace convert {
-grammar::RightRG < > ToGrammarRightRG::convert(const automaton::Automaton& automaton) {
- return dispatch(automaton.getData());
-}
-
grammar::RightRG < > ToGrammarRightRG::convert(const automaton::NFA < > & automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
@@ -58,8 +54,6 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::NFA < > & automa
return grammar;
}
-auto ToGrammarRightRGNFA = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, automaton::NFA < > >(ToGrammarRightRG::convert);
-
grammar::RightRG < > ToGrammarRightRG::convert(const automaton::DFA<>& automaton) {
ext::map<DefaultStateType, DefaultSymbolType> nonterminalMap;
@@ -101,7 +95,8 @@ grammar::RightRG < > ToGrammarRightRG::convert(const automaton::DFA<>& automaton
return grammar;
}
-auto ToGrammarRightRGDFA = registration::OverloadRegister < ToGrammarRightRG, grammar::RightRG < >, automaton::DFA < > >( ToGrammarRightRG::convert );
+auto ToGrammarRightRGNFA = registration::AbstractRegister < ToGrammarRightRG, grammar::RightRG < >, const automaton::NFA < > & > ( ToGrammarRightRG::convert );
+auto ToGrammarRightRGDFA = registration::AbstractRegister < ToGrammarRightRG, grammar::RightRG < >, const automaton::DFA < > & > ( ToGrammarRightRG::convert );
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToGrammarRightRG.h b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
index 41401a796d..a6b7f54e44 100644
--- a/alib2algo/src/automaton/convert/ToGrammarRightRG.h
+++ b/alib2algo/src/automaton/convert/ToGrammarRightRG.h
@@ -8,14 +8,10 @@
#ifndef __TO_GRAMMAR_RIGHT_RG_H__
#define __TO_GRAMMAR_RIGHT_RG_H__
-#include <core/multipleDispatch.hpp>
-
#include <grammar/Regular/RightRG.h>
#include <automaton/FSM/NFA.h>
#include <automaton/FSM/DFA.h>
-#include <automaton/Automaton.h>
-
namespace automaton {
namespace convert {
@@ -24,14 +20,12 @@ namespace convert {
* Finite automaton to right regular grammar converter.
* Source: Melichar 2.104
*/
-class ToGrammarRightRG : public alib::SingleDispatch<ToGrammarRightRG, grammar::RightRG < >, const automaton::AutomatonBase &> {
+class ToGrammarRightRG {
public:
/**
* Performs conversion.
* @return left regular grammar equivalent to source automaton.
*/
- static grammar::RightRG < > convert(const automaton::Automaton& automaton);
-
static grammar::RightRG < > convert(const automaton::NFA < > & automaton);
static grammar::RightRG < > convert(const automaton::DFA<>& automaton);
};
diff --git a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
index 47a16b6a80..adee3fdb78 100644
--- a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
+++ b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.cpp
@@ -25,10 +25,6 @@ namespace automaton {
namespace convert {
-automaton::Automaton ToPostfixPushdownAutomaton::convert ( const automaton::Automaton & automaton ) {
- return dispatch ( automaton.getData ( ) );
-}
-
automaton::DPDA < > ToPostfixPushdownAutomaton::convert ( const automaton::DFTA < > & dfta ) {
automaton::DPDA < > automaton(label::InitialStateLabel::instance < DefaultStateType > ( ), alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ));
@@ -101,8 +97,8 @@ automaton::NPDA < > ToPostfixPushdownAutomaton::convert ( const automaton::NFTA
return automaton;
}
-auto ToAutomatonDFTA = registration::OverloadRegister < ToPostfixPushdownAutomaton, automaton::DPDA < >, automaton::DFTA < > > ( ToPostfixPushdownAutomaton::convert );
-auto ToAutomatonNFTA = registration::OverloadRegister < ToPostfixPushdownAutomaton, automaton::NPDA < >, automaton::NFTA < > > ( ToPostfixPushdownAutomaton::convert );
+auto ToAutomatonDFTA = registration::AbstractRegister < ToPostfixPushdownAutomaton, automaton::DPDA < >, const automaton::DFTA < > & > ( ToPostfixPushdownAutomaton::convert );
+auto ToAutomatonNFTA = registration::AbstractRegister < ToPostfixPushdownAutomaton, automaton::NPDA < >, const automaton::NFTA < > & > ( ToPostfixPushdownAutomaton::convert );
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.h b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.h
index b935b6c380..6e9c9a4588 100644
--- a/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.h
+++ b/alib2algo/src/automaton/convert/ToPostfixPushdownAutomaton.h
@@ -8,9 +8,6 @@
#ifndef AUTOMATON_TO_AUTOMATON_H_
#define AUTOMATON_TO_AUTOMATON_H_
-#include <core/multipleDispatch.hpp>
-
-#include <automaton/Automaton.h>
#include <automaton/TA/DFTA.h>
#include <automaton/TA/NFTA.h>
#include <automaton/PDA/NPDA.h>
@@ -20,14 +17,12 @@ namespace automaton {
namespace convert {
-class ToPostfixPushdownAutomaton : public alib::SingleDispatch < ToPostfixPushdownAutomaton, automaton::Automaton, const automaton::AutomatonBase & > {
+class ToPostfixPushdownAutomaton {
public:
/**
* Performs conversion.
* @return PDA equivalent to original finite tree automaton reading linearized postfix tree
*/
- static automaton::Automaton convert ( const automaton::Automaton & automaton );
-
static automaton::DPDA < > convert ( const automaton::DFTA < > & dfta );
static automaton::NPDA < > convert ( const automaton::NFTA < > & nfta );
diff --git a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
index 4a08999697..63981fc7ff 100644
--- a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
+++ b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.cpp
@@ -20,10 +20,6 @@ namespace automaton {
namespace convert {
-regexp::RegExp ToRegExpAlgebraic::convert(const automaton::Automaton& automaton) {
- return dispatch(automaton.getData());
-}
-
regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::EpsilonNFA < > & automaton ) {
equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -51,8 +47,6 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::Epsilon
return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
}
-auto ToRegExpAlgebraicEpsilonNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > > ( ToRegExpAlgebraic::convert );
-
regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::MultiInitialStateNFA < > & automaton ) {
equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -82,8 +76,6 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::MultiIn
return regexp::UnboundedRegExp < > { regexp::UnboundedRegExpStructure < DefaultSymbolType > ( alternation ) };
}
-auto ToRegExpAlgebraicMultiInitialStateNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > > ( ToRegExpAlgebraic::convert );
-
regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::NFA < > & automaton ) {
equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -105,8 +97,6 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::NFA < >
return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
}
-auto ToRegExpAlgebraicNFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::NFA < > > ( ToRegExpAlgebraic::convert );
-
regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::DFA < > & automaton ) {
equations::RightRegularEquationSolver < DefaultSymbolType > solver;
@@ -126,7 +116,10 @@ regexp::UnboundedRegExp < > ToRegExpAlgebraic::convert( const automaton::DFA < >
return solver.solve( DefaultSymbolType( automaton.getInitialState() ) );
}
-auto ToRegExpAlgebraicDFA = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, automaton::DFA < > > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicEpsilonNFA = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const automaton::EpsilonNFA < > & > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicMultiInitialStateNFA = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const automaton::MultiInitialStateNFA < > & > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicNFA = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const automaton::NFA < > & > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicDFA = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const automaton::DFA < > & > ( ToRegExpAlgebraic::convert );
} /* namespace convert */
diff --git a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
index 72b78b383d..d96b39e7f4 100644
--- a/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/automaton/convert/ToRegExpAlgebraic.h
@@ -12,11 +12,7 @@
#include <map>
#include <queue>
-#include <core/multipleDispatch.hpp>
-
-#include <regexp/RegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
-#include <automaton/Automaton.h>
#include <automaton/AutomatonFeatures.h>
namespace automaton {
@@ -30,14 +26,12 @@ namespace convert {
* Converts FA to RE using Brzozowski's algebraic method using right regular equations.
* Source : Melichar 2.122
*/
-class ToRegExpAlgebraic : public alib::SingleDispatch<ToRegExpAlgebraic, regexp::RegExp, const automaton::AutomatonBase &> {
+class ToRegExpAlgebraic {
public:
/**
* Performs conversion.
* @return regular expression equivalent to input automaton.
*/
- static regexp::RegExp convert(const automaton::Automaton& automaton);
-
static regexp::UnboundedRegExp < > convert(const automaton::EpsilonNFA < > & automaton);
static regexp::UnboundedRegExp < > convert(const automaton::MultiInitialStateNFA < > & automaton);
static regexp::UnboundedRegExp < > convert(const automaton::NFA < > & automaton);
diff --git a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp b/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
index 6c74aea492..3dd0819a54 100644
--- a/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
+++ b/alib2algo/src/automaton/convert/ToRegExpStateElimination.cpp
@@ -7,10 +7,10 @@
#include "ToRegExpStateElimination.h"
-#include "../../regexp/simplify/RegExpOptimize.h"
-#include "../../regexp/transform/RegExpAlternate.h"
-#include "../../regexp/transform/RegExpConcatenate.h"
-#include "../../regexp/transform/RegExpIterate.h"
+#include <regexp/simplify/RegExpOptimize.h>
+#include <regexp/transform/RegExpAlternate.h>
+#include <regexp/transform/RegExpConcatenate.h>
+#include <regexp/transform/RegExpIterate.h>
#include <common/createUnique.hpp>
@@ -21,10 +21,6 @@ namespace automaton {
namespace convert {
-regexp::RegExp ToRegExpStateElimination::convert(const automaton::Automaton& automaton) {
- return dispatch(automaton.getData());
-}
-
template<class T>
regexp::UnboundedRegExp < > ToRegExpStateElimination::convert(const T& automaton) {
if(automaton.getFinalStates().size() == 0)
@@ -49,12 +45,12 @@ regexp::UnboundedRegExp < > ToRegExpStateElimination::convert(const T& automaton
return regexp::UnboundedRegExp < > (regexp::simplify::RegExpOptimize::optimize(initialToFinalState));
}
-auto ToRegExpStateEliminationEpsilonNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::EpsilonNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationMultiInitialStateNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::MultiInitialStateNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::NFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationDFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::DFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationExtendedNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::ExtendedNFA < > >(ToRegExpStateElimination::convert);
-auto ToRegExpStateEliminationCompactNFA = registration::OverloadRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, automaton::CompactNFA < > >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationEpsilonNFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::EpsilonNFA < > & >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationMultiInitialStateNFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::MultiInitialStateNFA < > & >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationNFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::NFA < > & >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationDFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::DFA < > & >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationExtendedNFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::ExtendedNFA < > & >(ToRegExpStateElimination::convert);
+auto ToRegExpStateEliminationCompactNFA = registration::AbstractRegister < ToRegExpStateElimination, regexp::UnboundedRegExp < >, const automaton::CompactNFA < > & >(ToRegExpStateElimination::convert);
automaton::ExtendedNFA < > ToRegExpStateElimination::eliminateState(const automaton::ExtendedNFA < > & extendedAutomaton, const DefaultStateType& q) {
automaton::ExtendedNFA < > newAutomaton(extendedAutomaton.getInitialState()); // sure that q is neither initial nor final (follows from step 2 - extending ExtendedNFA)
diff --git a/alib2algo/src/automaton/convert/ToRegExpStateElimination.h b/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
index 7df66ecd71..c4a3cb5e7e 100644
--- a/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
+++ b/alib2algo/src/automaton/convert/ToRegExpStateElimination.h
@@ -8,12 +8,8 @@
#ifndef TO_REG_EXP_STATE_ELIMINATION_H_
#define TO_REG_EXP_STATE_ELIMINATION_H_
-#include <core/multipleDispatch.hpp>
-
-#include <regexp/RegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
-#include <automaton/Automaton.h>
#include <automaton/FSM/DFA.h>
#include <automaton/FSM/NFA.h>
#include <automaton/FSM/MultiInitialStateNFA.h>
@@ -28,15 +24,13 @@ namespace convert {
* Converts FSM to RE using State Elimination algorithm.
* Source: Melichar 2.118
*/
-class ToRegExpStateElimination : public alib::SingleDispatch<ToRegExpStateElimination, regexp::RegExp, const automaton::AutomatonBase &> {
+class ToRegExpStateElimination {
public:
/**
* Performs conversion.
* @param automaton automaton to convert
* @return regular expression equivalent to source NFA.
*/
- static regexp::RegExp convert(const automaton::Automaton& automaton);
-
template<class T>
static regexp::UnboundedRegExp < > convert(const T& automaton);
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.cpp b/alib2algo/src/grammar/convert/ToAutomaton.cpp
index fe393a9bbd..e76d5f55e4 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomaton.cpp
@@ -16,10 +16,6 @@ namespace grammar {
namespace convert {
-automaton::Automaton ToAutomaton::convert(const grammar::Grammar& grammar) {
- return dispatch(grammar.getData());
-}
-
automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
ext::map<DefaultSymbolType, DefaultStateType> stateMap;
ext::set<DefaultStateType> states;
@@ -61,8 +57,6 @@ automaton::NFA < > ToAutomaton::convert(const grammar::LeftRG < > & grammar) {
return automaton;
}
-auto ToAutomatonLeftRG = registration::OverloadRegister < ToAutomaton, automaton::NFA < >, grammar::LeftRG < > > ( ToAutomaton::convert );
-
automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
ext::map<DefaultSymbolType, DefaultStateType> stateMap;
ext::set<DefaultStateType> states;
@@ -105,8 +99,6 @@ automaton::NFA < > ToAutomaton::convert(const grammar::RightRG < > & grammar) {
return automaton;
}
-auto ToAutomatonRightRG = registration::OverloadRegister < ToAutomaton, automaton::NFA < >, grammar::RightRG < > > ( ToAutomaton::convert );
-
template <class T>
automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
automaton::NPDA < > automaton(label::InitialStateLabel::instance < DefaultStateType > ( ), grammar.getInitialSymbol());
@@ -127,8 +119,10 @@ automaton::NPDA < > ToAutomaton::convert(const T& grammar) {
return automaton;
}
-auto ToAutomatonCFG = registration::OverloadRegister < ToAutomaton, automaton::NPDA < >, grammar::CFG < > > ( ToAutomaton::convert );
-auto ToAutomatonEpsilonFreeCFG = registration::OverloadRegister < ToAutomaton, automaton::NPDA < >, grammar::EpsilonFreeCFG < > > ( ToAutomaton::convert );
+auto ToAutomatonLeftRG = registration::AbstractRegister < ToAutomaton, automaton::NFA < >, const grammar::LeftRG < > & > ( ToAutomaton::convert );
+auto ToAutomatonRightRG = registration::AbstractRegister < ToAutomaton, automaton::NFA < >, const grammar::RightRG < > & > ( ToAutomaton::convert );
+auto ToAutomatonCFG = registration::AbstractRegister < ToAutomaton, automaton::NPDA < >, const grammar::CFG < > & > ( ToAutomaton::convert );
+auto ToAutomatonEpsilonFreeCFG = registration::AbstractRegister < ToAutomaton, automaton::NPDA < >, const grammar::EpsilonFreeCFG < > & > ( ToAutomaton::convert );
} /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToAutomaton.h b/alib2algo/src/grammar/convert/ToAutomaton.h
index 3c198b0306..541b154f79 100644
--- a/alib2algo/src/grammar/convert/ToAutomaton.h
+++ b/alib2algo/src/grammar/convert/ToAutomaton.h
@@ -8,15 +8,11 @@
#ifndef _GRAMMAR_TO_AUTOMATON_H_
#define _GRAMMAR_TO_AUTOMATON_H_
-#include <core/multipleDispatch.hpp>
-
-#include <grammar/Grammar.h>
#include <grammar/Regular/LeftRG.h>
#include <grammar/Regular/RightRG.h>
#include <grammar/ContextFree/CFG.h>
#include <grammar/ContextFree/EpsilonFreeCFG.h>
-#include <automaton/Automaton.h>
#include <automaton/FSM/NFA.h>
#include <automaton/PDA/NPDA.h>
@@ -28,15 +24,13 @@ namespace convert {
* Converts regular grammar to nondeterministic finite automaton.
* Sources: Melichar 2.98 (RightRG -> NFA) and 2.102 (LeftRG -> NFA).
*/
-class ToAutomaton : public alib::SingleDispatch<ToAutomaton, automaton::Automaton, const grammar::GrammarBase &> {
+class ToAutomaton {
public:
/**
* Performs conversion.
* @param grammar Regular grammar to convert.
* @return FSM equivalent to source grammar.
*/
- static automaton::Automaton convert(const grammar::Grammar& grammar);
-
static automaton::NFA < > convert(const grammar::LeftRG < > & grammar);
static automaton::NFA < > convert(const grammar::RightRG < > & grammar);
diff --git a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
index 3329e1c26e..5012256a8e 100644
--- a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
+++ b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.cpp
@@ -11,12 +11,8 @@ namespace grammar {
namespace convert {
-automaton::Automaton ToAutomatonBottomUp::convert(const grammar::Grammar& grammar) {
- return dispatch(grammar.getData());
-}
-
-auto ToAutomatonBottomUpCFG = registration::OverloadRegister < ToAutomatonBottomUp, automaton::NPDA < >, grammar::CFG < > > ( ToAutomatonBottomUp::convert );
-auto ToAutomatonBottomUpEpsilonFreeCFG = registration::OverloadRegister < ToAutomatonBottomUp, automaton::NPDA < >, grammar::EpsilonFreeCFG < > > ( ToAutomatonBottomUp::convert );
+auto ToAutomatonBottomUpCFG = registration::AbstractRegister < ToAutomatonBottomUp, automaton::NPDA < >, const grammar::CFG < > & > ( ToAutomatonBottomUp::convert );
+auto ToAutomatonBottomUpEpsilonFreeCFG = registration::AbstractRegister < ToAutomatonBottomUp, automaton::NPDA < >, const grammar::EpsilonFreeCFG < > & > ( ToAutomatonBottomUp::convert );
} /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.h b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.h
index 206898013c..03be378593 100644
--- a/alib2algo/src/grammar/convert/ToAutomatonBottomUp.h
+++ b/alib2algo/src/grammar/convert/ToAutomatonBottomUp.h
@@ -8,13 +8,10 @@
#ifndef _GRAMMAR_TO_AUTOMATON_BOTTOMUP_H_
#define _GRAMMAR_TO_AUTOMATON_BOTTOMUP_H_
-#include <core/multipleDispatch.hpp>
-
#include <grammar/Grammar.h>
#include <grammar/ContextFree/CFG.h>
#include <grammar/ContextFree/EpsilonFreeCFG.h>
-#include <automaton/Automaton.h>
#include <automaton/PDA/NPDA.h>
#include <alphabet/BottomOfTheStackSymbol.h>
@@ -27,13 +24,11 @@ namespace convert {
/**
*/
-class ToAutomatonBottomUp : public alib::SingleDispatch<ToAutomatonBottomUp, automaton::Automaton, const grammar::GrammarBase &> {
+class ToAutomatonBottomUp {
public:
/**
* Performs conversion.
*/
- static automaton::Automaton convert(const grammar::Grammar& grammar);
-
template <class T, class SymbolType = typename grammar::SymbolTypeOfGrammar < T >, class EpsilonType = DefaultEpsilonType, class StateType = DefaultStateType >
static automaton::NPDA < SymbolType, EpsilonType, SymbolType, StateType > convert(const T& grammar);
};
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
index bb1c3d3027..1aa50c530d 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.cpp
@@ -12,12 +12,8 @@ namespace grammar {
namespace convert {
-regexp::RegExp ToRegExpAlgebraic::convert(const grammar::Grammar& grammar) {
- return dispatch(grammar.getData());
-}
-
-auto ToRegExpAlgebraicLeftRG = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, grammar::LeftRG < > > ( ToRegExpAlgebraic::convert );
-auto ToRegExpAlgebraicRightRG = registration::OverloadRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, grammar::RightRG < > > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicLeftRG = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const grammar::LeftRG < > & > ( ToRegExpAlgebraic::convert );
+auto ToRegExpAlgebraicRightRG = registration::AbstractRegister < ToRegExpAlgebraic, regexp::UnboundedRegExp < >, const grammar::RightRG < > & > ( ToRegExpAlgebraic::convert );
} /* namespace convert */
diff --git a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
index b8a59b94f3..9865e46bfe 100644
--- a/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
+++ b/alib2algo/src/grammar/convert/ToRegExpAlgebraic.h
@@ -8,14 +8,9 @@
#ifndef GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_
#define GRAMMAR_TO_REG_EXP_ALGEBRAIC_H_
-#include <core/multipleDispatch.hpp>
-
-#include <grammar/Grammar.h>
#include <grammar/Regular/RightRG.h>
#include <grammar/Regular/LeftRG.h>
-#include <regexp/RegExp.h>
-
#include <equations/LeftRegularEquationSolver.h>
#include <equations/RightRegularEquationSolver.h>
@@ -26,14 +21,12 @@ namespace grammar {
namespace convert {
-class ToRegExpAlgebraic : public alib::SingleDispatch<ToRegExpAlgebraic, regexp::RegExp, const grammar::GrammarBase &> {
+class ToRegExpAlgebraic {
public:
/**
* @return regexp equivalent to source right regular grammar.
* @param grammar Grammar to convert
*/
- static regexp::RegExp convert(const grammar::Grammar& grammar);
-
template < class SymbolType >
static regexp::UnboundedRegExp < SymbolType > convert(const grammar::RightRG < SymbolType > & grammar);
template < class SymbolType >
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
index 71cf366f48..403ba7c433 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.cpp
@@ -24,10 +24,6 @@ namespace regexp {
namespace convert {
-automaton::DFA<> ToAutomatonDerivation::convert(const regexp::RegExp& regexp) {
- return dispatch(regexp.getData());
-}
-
template<class T>
automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
// 1.
@@ -100,8 +96,8 @@ automaton::DFA<> ToAutomatonDerivation::convert(const T& regexp) {
return automaton;
}
-auto ToAutomatonDerivationFormalRegExp = registration::OverloadRegister < ToAutomatonDerivation, automaton::DFA < >, regexp::FormalRegExp < > > ( ToAutomatonDerivation::convert );
-auto ToAutomatonDerivationUnboundedRegExp = registration::OverloadRegister < ToAutomatonDerivation, automaton::DFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonDerivation::convert );
+auto ToAutomatonDerivationFormalRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonDerivation::convert );
+auto ToAutomatonDerivationUnboundedRegExp = registration::AbstractRegister < ToAutomatonDerivation, automaton::DFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonDerivation::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
index 8e7328a9f8..7c0f253771 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonDerivation.h
@@ -8,9 +8,6 @@
#ifndef TO_AUTOMATON_DERIVATION_H_
#define TO_AUTOMATON_DERIVATION_H_
-#include <core/multipleDispatch.hpp>
-
-#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
@@ -24,14 +21,12 @@ namespace convert {
* Converts regular expression to finite automaton using BrzozowskiDerivation algorithm (derivations of regular expressions).
* Source: Melichar 2.110
*/
-class ToAutomatonDerivation : public alib::SingleDispatch<ToAutomatonDerivation, automaton::DFA<>, const regexp::RegExpBase &> {
+class ToAutomatonDerivation {
public:
/**
* Performs conversion.
* @return FSM equivalent to original regular expression.
*/
- static automaton::DFA<> convert(const regexp::RegExp& regexp);
-
template<class T>
static automaton::DFA<> convert(const T& regexp);
};
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index e4fb3ec6f4..12c7d17468 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -8,7 +8,6 @@
#include "ToAutomatonGlushkov.h"
#include <common/DefaultStatesPairType.h>
-#include <automaton/Automaton.h>
#include <global/GlobalData.h>
@@ -25,10 +24,6 @@ namespace regexp {
namespace convert {
-automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::RegExp & regexp ) {
- return dispatch ( regexp.getData ( ) );
-}
-
automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp < > & regexp ) {
DefaultStateType q0 ( DefaultStatesPairType ( ext::make_pair ( DefaultStateType ( 'q' ), DefaultStateType ( 0 ) ) ) );
automaton::NFA < > automaton ( q0 );
@@ -82,13 +77,12 @@ automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp
return automaton;
}
-auto ToAutomatonGlushkovUnboundedRegExp = registration::OverloadRegister < ToAutomatonGlushkov, automaton::NFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonGlushkov::convert );
-
automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::FormalRegExp < > & /* regexp */ ) {
throw exception::CommonException ( "Glushkov: Converting FormalRegExp NYI" ); // TODO
}
-auto ToAutomatonGlushkovFormalRegExp = registration::OverloadRegister < ToAutomatonGlushkov, automaton::NFA < >, regexp::FormalRegExp < > > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovUnboundedRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovFormalRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonGlushkov::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
index bdf3273b95..c1d2797b46 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
@@ -8,11 +8,9 @@
#ifndef TO_AUTOMATON_GLUSHKOV_H_
#define TO_AUTOMATON_GLUSHKOV_H_
-#include <core/multipleDispatch.hpp>
#include <map>
#include <automaton/FSM/NFA.h>
-#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
@@ -24,15 +22,13 @@ namespace convert {
* Converts regular expression to finite automaton using Glushkov's NFA construction algorithm.
* Source: Melichar 2.107
*/
-class ToAutomatonGlushkov : public alib::SingleDispatch<ToAutomatonGlushkov, automaton::NFA < >, const regexp::RegExpBase & > {
+class ToAutomatonGlushkov {
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);
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
index b2aa6ca93c..df206bbe41 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.cpp
@@ -14,10 +14,6 @@ namespace regexp {
namespace convert {
-automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::RegExp& regexp) {
- return dispatch(regexp.getData());
-}
-
automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::FormalRegExp < > & regexp) {
//FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
int nextState = 1;
@@ -37,8 +33,6 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::FormalRegEx
return automaton;
}
-auto ToAutomatonThompsonFormalRegExp = registration::OverloadRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, regexp::FormalRegExp < > > ( ToAutomatonThompson::convert );
-
automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRegExp < > & regexp) {
//FIXME use actual algorithms that implement product alternation and iteration of re over automata and remove terrible TERRIBLE hack with dummy initial state
int nextState = 1;
@@ -58,7 +52,8 @@ automaton::EpsilonNFA < > ToAutomatonThompson::convert(const regexp::UnboundedRe
return automaton;
}
-auto ToAutomatonThompsonUnboundedRegExp = registration::OverloadRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, regexp::UnboundedRegExp < > > ( ToAutomatonThompson::convert );
+auto ToAutomatonThompsonFormalRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonThompson::convert );
+auto ToAutomatonThompsonUnboundedRegExp = registration::AbstractRegister < ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonThompson::convert );
// ----------------------------------------------------------------------------
diff --git a/alib2algo/src/regexp/convert/ToAutomatonThompson.h b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
index e292982a29..c6973cd0c4 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonThompson.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonThompson.h
@@ -8,9 +8,6 @@
#ifndef TO_AUTOMATON_THOMPSON_H_
#define TO_AUTOMATON_THOMPSON_H_
-#include <core/multipleDispatch.hpp>
-
-#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/formal/FormalRegExpElement.h>
#include <regexp/unbounded/UnboundedRegExp.h>
@@ -29,15 +26,13 @@ namespace convert {
* http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.7450&rep=rep1&type=ps
* Melichar 2.112
*/
-class ToAutomatonThompson : public alib::SingleDispatch<ToAutomatonThompson, automaton::EpsilonNFA < >, const regexp::RegExpBase &> {
+class ToAutomatonThompson {
public:
/**
* Performs conversion.
* @param regexp regexp to convert
* @return nondeterministic finite automaton with epsilon transitions accepting language described by the regexp
*/
- static automaton::EpsilonNFA < > convert(const regexp::RegExp& regexp);
-
static automaton::EpsilonNFA < > convert(const regexp::FormalRegExp < > & regexp);
static automaton::EpsilonNFA < > convert(const regexp::UnboundedRegExp < > & regexp);
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
index dae122fb05..24cd5d0ae6 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.cpp
@@ -24,10 +24,6 @@ namespace regexp {
namespace convert {
-grammar::RightRG < > ToGrammarRightRGDerivation::convert(const regexp::RegExp& regexp) {
- return dispatch(regexp.getData());
-}
-
template<class T>
grammar::RightRG < > ToGrammarRightRGDerivation::convert(const T& regexp) {
// 1.
@@ -102,8 +98,8 @@ grammar::RightRG < > ToGrammarRightRGDerivation::convert(const T& regexp) {
return grammar;
}
-auto ToGrammarRightRGDerivationUnboundedRegExp = registration::OverloadRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, regexp::UnboundedRegExp < > > ( ToGrammarRightRGDerivation::convert );
-auto ToGrammarRightRGDerivationFormalRegExp = registration::OverloadRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, regexp::FormalRegExp < > > ( ToGrammarRightRGDerivation::convert );
+auto ToGrammarRightRGDerivationUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGDerivation::convert );
+auto ToGrammarRightRGDerivationFormalRegExp = registration::AbstractRegister < ToGrammarRightRGDerivation, grammar::RightRG < >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGDerivation::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
index 1eb3fce712..b708b30217 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGDerivation.h
@@ -8,10 +8,7 @@
#ifndef TO_GRAMMAR_RIGHT_RG_DERIVATION_H_
#define TO_GRAMMAR_RIGHT_RG_DERIVATION_H_
-#include <core/multipleDispatch.hpp>
-
#include <grammar/Regular/RightRG.h>
-#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
@@ -23,14 +20,12 @@ namespace convert {
* Converts reg. expression to right regular grammar using brzozowski derivation algorithm.
* Source: Melichar 2.137
*/
-class ToGrammarRightRGDerivation : public alib::SingleDispatch<ToGrammarRightRGDerivation, grammar::RightRG < >, const regexp::RegExpBase &> {
+class ToGrammarRightRGDerivation {
public:
/**
* Performs conversion.
* @return right regular grammar equivalent to source regexp.
*/
- static grammar::RightRG < > convert(const regexp::RegExp& regexp);
-
template <class T>
static grammar::RightRG < > convert(const T& regexp);
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index bc04bb4cc2..ef016493b2 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -24,10 +24,6 @@ namespace regexp {
namespace convert {
-grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::RegExp & regexp ) {
- return dispatch ( regexp.getData ( ) );
-}
-
grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::UnboundedRegExp < > & regexp ) {
DefaultSymbolType S = alphabet::InitialSymbol::instance < DefaultSymbolType > ( );
grammar::RightRG < > grammar ( S );
@@ -84,13 +80,12 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
return grammar;
}
-auto ToGrammarRightRGGlushkovUnboundedRegExp = registration::OverloadRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, regexp::UnboundedRegExp < > > ( ToGrammarRightRGGlushkov::convert );
-
grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::FormalRegExp < > & /* regexp */ ) {
throw exception::CommonException ( "Glushkov: Converting FormalRegExp NYI" ); // TODO
}
-auto ToGrammarRightRGGlushkovFormalRegExp = registration::OverloadRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, regexp::FormalRegExp < > > ( ToGrammarRightRGGlushkov::convert );
+auto ToGrammarRightRGGlushkovUnboundedRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, const regexp::UnboundedRegExp < > & > ( ToGrammarRightRGGlushkov::convert );
+auto ToGrammarRightRGGlushkovFormalRegExp = registration::AbstractRegister < ToGrammarRightRGGlushkov, grammar::RightRG < >, const regexp::FormalRegExp < > & > ( ToGrammarRightRGGlushkov::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
index b9659b7ea8..3fe820d47b 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.h
@@ -8,11 +8,7 @@
#ifndef TO_GRAMMAR_RIGHT_RG_GLUSHKOV_H_
#define TO_GRAMMAR_RIGHT_RG_GLUSHKOV_H_
-#include <core/multipleDispatch.hpp>
-
#include <grammar/Regular/RightRG.h>
-
-#include <regexp/RegExp.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
@@ -24,15 +20,13 @@ namespace convert {
* Converts regular expression to right regular grammar using Glushkov algorithm.
* Source: None yet.
*/
-class ToGrammarRightRGGlushkov : public alib::SingleDispatch<ToGrammarRightRGGlushkov, grammar::RightRG < >, const regexp::RegExpBase &> {
+class ToGrammarRightRGGlushkov {
public:
/**
* Performs conversion.
* @param regexp original regular expression
* @return right regular grammar equivalent to source regexp.
*/
- static grammar::RightRG < > convert(const regexp::RegExp& regexp);
-
static grammar::RightRG < > convert(const regexp::FormalRegExp < > & regexp);
static grammar::RightRG < > convert(const regexp::UnboundedRegExp < > & regexp);
};
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
index 8f1c3ea3fc..30d8dc8304 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.cpp
@@ -7,7 +7,6 @@
#include "ToPostfixPushdownAutomatonGlushkov.h"
-#include <automaton/Automaton.h>
#include <alphabet/BottomOfTheStackSymbol.h>
#include <alphabet/EndSymbol.h>
@@ -23,10 +22,6 @@ namespace rte {
namespace convert {
-automaton::Automaton ToPostfixPushdownAutomatonGlushkov::convert ( const rte::RTE & rte ) {
- return dispatch ( rte.getData ( ) );
-}
-
template < class SymbolType, class RankType >
bool ToPostfixPushdownAutomatonGlushkov::isSubstSymbolPresent ( const ext::set < common::ranked_symbol < SymbolType, RankType > > & container, const TAlphabet < SymbolType, RankType > & substAlphabet ) {
ext::vector < common::ranked_symbol < > > intersection;
@@ -221,9 +216,9 @@ ToPostfixPushdownAutomatonGlushkov::convert ( const rte::FormalRTE < > & rte ) {
return automaton;
}
-auto ToPostfixPushdownAutomatonGlushkovFormalRTE = registration::OverloadRegister < ToPostfixPushdownAutomatonGlushkov,
+auto ToPostfixPushdownAutomatonGlushkovFormalRTE = registration::AbstractRegister < ToPostfixPushdownAutomatonGlushkov,
automaton::NPDA < DefaultSymbolType, DefaultEpsilonType, ext::variant < alphabet::BottomOfTheStackSymbol, ext::set < common::ranked_symbol < alib::Object, primitive::Unsigned > > >, DefaultStateType >,
- rte::FormalRTE < > > ( ToPostfixPushdownAutomatonGlushkov::convert );
+ const rte::FormalRTE < > & > ( ToPostfixPushdownAutomatonGlushkov::convert );
} /* namespace convert */
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.h b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.h
index 86b9bde610..e6c6636258 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.h
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkov.h
@@ -8,12 +8,10 @@
#ifndef TO_POSTFIX_PUSHDOWN_AUTOMATON_GLUSHKOV_H_
#define TO_POSTFIX_PUSHDOWN_AUTOMATON_GLUSHKOV_H_
-#include <core/multipleDispatch.hpp>
#include <map>
#include <automaton/PDA/NPDA.h>
-#include <rte/RTE.h>
#include <rte/formal/FormalRTE.h>
#include <container/ObjectsVariant.h>
@@ -27,7 +25,7 @@ namespace convert {
* Converts regular tree expression to real-time height-deterministic pda
* Source: Master Thesis, Pecka Tomas, CTU FIT, 2016, chapter 4.2
*/
-class ToPostfixPushdownAutomatonGlushkov : public alib::SingleDispatch < ToPostfixPushdownAutomatonGlushkov, automaton::Automaton, const rte::RTEBase & > {
+class ToPostfixPushdownAutomatonGlushkov {
private:
// --------------------------------------------------------------------
@@ -45,8 +43,6 @@ public:
* @param re Original regular tree expression.
* @return rhNPDA equivalent to original regular expression.
*/
- static automaton::Automaton convert ( const rte::RTE & rte );
-
template < class SymbolType, class RankType >
static automaton::NPDA < SymbolType, DefaultEpsilonType, ext::variant < alphabet::BottomOfTheStackSymbol, ext::set < common::ranked_symbol < SymbolType, RankType > > >, DefaultStateType > convert ( const rte::FormalRTE < > & rte );
};
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.cpp b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.cpp
index d8874ac127..b3d467503b 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.cpp
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.cpp
@@ -10,8 +10,6 @@
#include <alphabet/BottomOfTheStackSymbol.h>
#include <alphabet/EndSymbol.h>
-#include <automaton/Automaton.h>
-
#include <global/GlobalData.h>
#include <registration/AlgoRegistration.hpp>
@@ -24,10 +22,6 @@ namespace rte {
namespace convert {
-automaton::NPDA < > ToPostfixPushdownAutomatonGlushkovNaive::convert ( const rte::RTE & rte ) {
- return dispatch ( rte.getData ( ) );
-}
-
ext::vector < DefaultSymbolType > phi ( const ext::vector < common::ranked_symbol < > > & follow ) {
return ext::transform < DefaultSymbolType > ( follow, []( const common::ranked_symbol < > & symbol ) { return DefaultSymbolType ( alphabet::RankedSymbol < > ( symbol ) ); } );
}
@@ -137,7 +131,7 @@ automaton::NPDA < > ToPostfixPushdownAutomatonGlushkovNaive::convert ( const rte
return automaton;
}
-auto ToPostfixPushdownAutomatonGlushkovNaiveFormalRTE = registration::OverloadRegister < ToPostfixPushdownAutomatonGlushkovNaive, automaton::NPDA < >, rte::FormalRTE < > > ( ToPostfixPushdownAutomatonGlushkovNaive::convert );
+auto ToPostfixPushdownAutomatonGlushkovNaiveFormalRTE = registration::AbstractRegister < ToPostfixPushdownAutomatonGlushkovNaive, automaton::NPDA < >, const rte::FormalRTE < > & > ( ToPostfixPushdownAutomatonGlushkovNaive::convert );
} /* namespace convert */
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.h b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.h
index 327ba27f7a..bcbe8736d5 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.h
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovNaive.h
@@ -8,12 +8,9 @@
#ifndef TO_POSTFIX_PUSHDOWN_AUTOMATON_GLUSHKOV_NAIVE_H_
#define TO_POSTFIX_PUSHDOWN_AUTOMATON_GLUSHKOV_NAIVE_H_
-#include <core/multipleDispatch.hpp>
#include <map>
-#include <automaton/FSM/NFA.h>
#include <automaton/PDA/NPDA.h>
-#include <rte/RTE.h>
#include <rte/formal/FormalRTE.h>
// #include <rte/unbounded/UnboundedRegExp.h>
@@ -26,14 +23,13 @@ namespace convert {
* Converts regular tree expression to real-time height-deterministic pda
* Source: Master Thesis, Pecka Tomas, CTU FIT, 2016, chapter 4.2
*/
-class ToPostfixPushdownAutomatonGlushkovNaive : public alib::SingleDispatch < ToPostfixPushdownAutomatonGlushkovNaive, automaton::NPDA < >, const rte::RTEBase & > {
+class ToPostfixPushdownAutomatonGlushkovNaive {
public:
/**
* Performs conversion.
* @param re Original regular tree expression.
* @return rhNPDA equivalent to original regular expression.
*/
- static automaton::NPDA < > convert ( const rte::RTE & rte );
static automaton::NPDA < > convert ( const rte::FormalRTE < > & rte );
};
diff --git a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
index 0a26602fa8..1f38da1ac1 100644
--- a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
+++ b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
@@ -26,11 +26,11 @@ void re2faTest::tearDown() {
void re2faTest::testThompson() {
std::string input = "a+a* b*";
- regexp::RegExp regexp1 = alib::StringDataFactory::fromString (input);
+ regexp::UnboundedRegExp < > regexp1 = alib::StringDataFactory::fromString (input);
automaton::EpsilonNFA < > enfa1 = regexp::convert::ToAutomatonThompson::convert(regexp1);
- regexp::RegExp regexp2( automaton::convert::ToRegExpAlgebraic::convert( enfa1) );
+ regexp::UnboundedRegExp < > regexp2 ( automaton::convert::ToRegExpAlgebraic::convert( enfa1) );
automaton::EpsilonNFA < > enfa2 = regexp::convert::ToAutomatonThompson::convert(regexp2);
@@ -48,7 +48,7 @@ void re2faTest::testThompson() {
void re2faTest::testGlushkov() {
std::string input = "a+a*b*";
- regexp::RegExp regexp1 = alib::StringDataFactory::fromString ( input );
+ regexp::UnboundedRegExp < > regexp1 = alib::StringDataFactory::fromString ( input );
automaton::NFA < > nfa1 = regexp::convert::ToAutomatonGlushkov::convert ( regexp1 );
@@ -73,11 +73,11 @@ void re2faTest::testGlushkov() {
void re2faTest::testBrzozowski() {
std::string input = "a+a* b*";
- regexp::RegExp regexp1 = alib::StringDataFactory::fromString (input);
+ regexp::UnboundedRegExp < > regexp1 = alib::StringDataFactory::fromString (input);
automaton::DFA<> dfa1 = regexp::convert::ToAutomatonDerivation::convert(regexp1);
- regexp::RegExp regexp2( automaton::convert::ToRegExpAlgebraic::convert(dfa1));
+ regexp::UnboundedRegExp < > regexp2( automaton::convert::ToRegExpAlgebraic::convert(dfa1));
automaton::DFA<> dfa2 = regexp::convert::ToAutomatonDerivation::convert(regexp2);
--
GitLab