diff --git a/alib2algo/src/regexp/convert/ToAutomaton.cpp b/alib2algo/src/regexp/convert/ToAutomaton.cpp
index 9bb07eb141806a5e9a260a8ab917dc559eb56a01..ba158c333f40dd6d7450b310ed547d4719d94218 100644
--- a/alib2algo/src/regexp/convert/ToAutomaton.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomaton.cpp
@@ -12,8 +12,8 @@ namespace regexp {
namespace convert {
-auto ToAutomatonFormalRegExp = registration::AbstractRegister < ToAutomaton, automaton::NFA < >, const regexp::FormalRegExp < > & > ( ToAutomaton::convert );
-auto ToAutomatonUnboundedRegExp = registration::AbstractRegister < ToAutomaton, automaton::NFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomaton::convert );
+auto ToAutomatonFormalRegExp = registration::AbstractRegister < ToAutomaton, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToAutomaton::convert );
+auto ToAutomatonUnboundedRegExp = registration::AbstractRegister < ToAutomaton, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToAutomaton::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomaton.h b/alib2algo/src/regexp/convert/ToAutomaton.h
index 5e226063be9be59a116fd732211133bb93be4214..ea03a2028e894d336da2abb6e27f4b45a936dc4b 100644
--- a/alib2algo/src/regexp/convert/ToAutomaton.h
+++ b/alib2algo/src/regexp/convert/ToAutomaton.h
@@ -24,20 +24,20 @@ public:
* @return FSM equivalent to original regular expression.
*/
template < class SymbolType >
- static automaton::NFA < > convert(const regexp::FormalRegExp < SymbolType > & regexp);
+ static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::FormalRegExp < SymbolType > & regexp );
template < class SymbolType >
- static automaton::NFA < > convert(const regexp::UnboundedRegExp < SymbolType > & regexp);
+ static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::UnboundedRegExp < SymbolType > & regexp );
};
template < class SymbolType >
-automaton::NFA < > ToAutomaton::convert(const regexp::FormalRegExp < SymbolType > & regexp) {
- return ToAutomatonGlushkov::convert(regexp);
+automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > ToAutomaton::convert ( const regexp::FormalRegExp < SymbolType > & regexp ) {
+ return ToAutomatonGlushkov::convert ( regexp );
}
template < class SymbolType >
-automaton::NFA < > ToAutomaton::convert(const regexp::UnboundedRegExp < SymbolType > & regexp) {
- return ToAutomatonGlushkov::convert(regexp);
+automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > ToAutomaton::convert ( const regexp::UnboundedRegExp < SymbolType > & regexp ) {
+ return ToAutomatonGlushkov::convert ( regexp );
}
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
index 6c7c9262fc44a12c059cb168cbf7573728d4eb3a..8e8b4d6b2838531d7e161e4c051179240b2e876a 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.cpp
@@ -6,83 +6,14 @@
*/
#include "ToAutomatonGlushkov.h"
-
-#include <common/DefaultStatesPairType.h>
-
-#include <global/GlobalData.h>
-
-#include "../glushkov/GlushkovFirst.h"
-#include "../glushkov/GlushkovFollow.h"
-#include "../glushkov/GlushkovIndexate.h"
-#include "../glushkov/GlushkovLast.h"
-
-#include <regexp/properties/RegExpEpsilon.h>
-#include <exception/CommonException.h>
#include <registration/AlgoRegistration.hpp>
namespace regexp {
namespace convert {
-automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp < > & regexp ) {
- DefaultStateType q0 ( DefaultStatesPairType ( ext::make_pair ( DefaultStateType ( 'q' ), DefaultStateType ( 0 ) ) ) );
- automaton::NFA < > automaton ( q0 );
-
- // step 1
- automaton.setInputAlphabet ( regexp.getAlphabet ( ) );
-
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
-
- // steps 2, 3, 4
- const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
- const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
-
- // \e in q0 check is in step 7
-
- // step 5
- for ( const ext::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
- automaton.addState ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol ) ) );
-
- // step 6
- for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : first )
- automaton.addTransition ( q0, symbol.getSymbol ( ).first, DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) );
-
- for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- for ( const auto & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) ) {
- const ext::pair < DefaultSymbolType, int > & p = x;
- const ext::pair < DefaultSymbolType, int > & q = f.getSymbol ( );
-
- automaton.addTransition ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( p ) ), q.first, DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( q ) ) );
- }
-
- // step 7
-
- for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : last )
- automaton.addFinalState ( DefaultStateType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) );
-
- if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
- automaton.addFinalState ( q0 );
-
- if ( common::GlobalData::verbose ) {
- common::Streams::log << "First:" << first << std::endl;
- common::Streams::log << "Last: " << last << std::endl;
-
- if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
- common::Streams::log << " q0 because #E in L(RE)" << std::endl;
-
- for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- common::Streams::log << "Follow(" << x << ") = " << regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) << std::endl;
- }
-
- return automaton;
-}
-
-automaton::NFA < > ToAutomatonGlushkov::convert ( const regexp::FormalRegExp < > & regexp ) {
- return ToAutomatonGlushkov::convert ( regexp::UnboundedRegExp < > ( regexp ) );
-}
-
-auto ToAutomatonGlushkovUnboundedRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < >, const regexp::UnboundedRegExp < > & > ( ToAutomatonGlushkov::convert );
-auto ToAutomatonGlushkovFormalRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < >, const regexp::FormalRegExp < > & > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovUnboundedRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::UnboundedRegExp < > & > ( ToAutomatonGlushkov::convert );
+auto ToAutomatonGlushkovFormalRegExp = registration::AbstractRegister < ToAutomatonGlushkov, automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > >, const regexp::FormalRegExp < > & > ( ToAutomatonGlushkov::convert );
} /* namespace convert */
diff --git a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
index 76a692d5fbdd2fc7eac8121f52bbb4299edf319b..51950b4183480134a80e428295a3153eee0947d7 100644
--- a/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
+++ b/alib2algo/src/regexp/convert/ToAutomatonGlushkov.h
@@ -8,10 +8,23 @@
#ifndef TO_AUTOMATON_GLUSHKOV_H_
#define TO_AUTOMATON_GLUSHKOV_H_
-#include <automaton/FSM/NFA.h>
#include <regexp/formal/FormalRegExp.h>
#include <regexp/unbounded/UnboundedRegExp.h>
+#include <automaton/FSM/NFA.h>
+
+#include <global/GlobalData.h>
+
+#include "../glushkov/GlushkovFirst.h"
+#include "../glushkov/GlushkovFollow.h"
+#include "../glushkov/GlushkovIndexate.h"
+#include "../glushkov/GlushkovLast.h"
+
+#include <regexp/properties/RegExpEpsilon.h>
+#include <exception/CommonException.h>
+
+#include <label/InitialStateLabel.h>
+
namespace regexp {
namespace convert {
@@ -27,11 +40,76 @@ public:
* @param re Original regular expression.
* @return NFA equivalent to original regular expression.
*/
- static automaton::NFA < > convert(const regexp::UnboundedRegExp < > & re);
- static automaton::NFA < > convert(const regexp::FormalRegExp < > & re);
+ template < class SymbolType >
+ static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::UnboundedRegExp < SymbolType > & regexp );
+
+ /**
+ * \overload
+ */
+ template < class SymbolType >
+ static automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > convert ( const regexp::FormalRegExp < SymbolType > & regexp );
};
+template < class SymbolType >
+automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > ToAutomatonGlushkov::convert ( const regexp::UnboundedRegExp < SymbolType > & regexp ) {
+ ext::pair < SymbolType, unsigned > q0 ( label::InitialStateLabel::instance < SymbolType > ( ), 0 );
+ automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > automaton ( q0 );
+
+ // step 1
+ automaton.setInputAlphabet ( regexp.getAlphabet ( ) );
+
+ regexp::UnboundedRegExp < ext::pair < SymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+
+ // steps 2, 3, 4
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+
+ // \e in q0 check is in step 7
+
+ // step 5
+ for ( const ext::pair < SymbolType, unsigned > & symbol : indexedRegExp.getAlphabet ( ) )
+ automaton.addState ( symbol );
+
+ // step 6
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > & symbol : first )
+ automaton.addTransition ( q0, symbol.getSymbol ( ).first, symbol.getSymbol ( ) );
+
+ for ( const ext::pair < SymbolType, unsigned > & x : indexedRegExp.getAlphabet ( ) )
+ for ( const auto & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > ( x ) ) ) {
+ const ext::pair < SymbolType, unsigned > & p = x;
+ const ext::pair < SymbolType, unsigned > & q = f.getSymbol ( );
+
+ automaton.addTransition ( p, q.first, q );
+ }
+
+ // step 7
+
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > & symbol : last )
+ automaton.addFinalState ( symbol.getSymbol ( ) );
+
+ if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
+ automaton.addFinalState ( q0 );
+
+ if ( common::GlobalData::verbose ) {
+ common::Streams::log << "First:" << first << std::endl;
+ common::Streams::log << "Last: " << last << std::endl;
+
+ if ( regexp::properties::RegExpEpsilon::languageContainsEpsilon ( regexp ) )
+ common::Streams::log << " q0 because #E in L(RE)" << std::endl;
+
+ for ( const ext::pair < SymbolType, unsigned > & x : indexedRegExp.getAlphabet ( ) )
+ common::Streams::log << "Follow(" << x << ") = " << regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > ( x ) ) << std::endl;
+ }
+
+ return automaton;
+}
+
+template < class SymbolType >
+automaton::NFA < SymbolType, ext::pair < SymbolType, unsigned > > ToAutomatonGlushkov::convert ( const regexp::FormalRegExp < SymbolType > & regexp ) {
+ return ToAutomatonGlushkov::convert ( regexp::UnboundedRegExp < > ( regexp ) );
+}
+
} /* namespace convert */
} /* namespace regexp */
diff --git a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
index 348121a9a19c3cef8b8bb34c38187aa4dbb20841..5b1db35cb0758ae5d289b0a0bcd17281ca448339 100644
--- a/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
+++ b/alib2algo/src/regexp/convert/ToGrammarRightRGGlushkov.cpp
@@ -33,28 +33,28 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
// step 1
grammar.setTerminalAlphabet ( regexp.getAlphabet ( ) );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
// steps 2, 3, 4
- const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
- const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ const ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > last = regexp::GlushkovLast::last ( indexedRegExp );
// \e in q0 check is in step 7
// step 5
- for ( const ext::pair < DefaultSymbolType, int > & symbol : indexedRegExp.getAlphabet ( ) )
- grammar.addNonterminalSymbol ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol ) ) );
+ for ( const ext::pair < DefaultSymbolType, unsigned > & symbol : indexedRegExp.getAlphabet ( ) )
+ grammar.addNonterminalSymbol ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, unsigned > ( symbol ) ) );
// step 6
- for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : first )
- grammar.addRule ( S, ext::make_pair ( symbol.getSymbol ( ).first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( symbol.getSymbol ( ) ) ) ) );
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > & symbol : first )
+ grammar.addRule ( S, ext::make_pair ( symbol.getSymbol ( ).first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, unsigned > ( symbol.getSymbol ( ) ) ) ) );
- for ( const ext::pair < DefaultSymbolType, int > & x : indexedRegExp.getAlphabet ( ) )
- for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( x ) ) ) {
- const ext::pair < DefaultSymbolType, int > & a = x;
- const ext::pair < DefaultSymbolType, int > & b = f.getSymbol ( );
+ for ( const ext::pair < DefaultSymbolType, unsigned > & x : indexedRegExp.getAlphabet ( ) )
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > & f : regexp::GlushkovFollow::follow ( indexedRegExp, UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( x ) ) ) {
+ const ext::pair < DefaultSymbolType, unsigned > & a = x;
+ const ext::pair < DefaultSymbolType, unsigned > & b = f.getSymbol ( );
- grammar.addRule ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( a ) ), ext::make_pair ( b.first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( b ) ) ) );
+ grammar.addRule ( DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, unsigned > ( a ) ), ext::make_pair ( b.first, DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, unsigned > ( b ) ) ) );
}
// step 7
@@ -66,11 +66,11 @@ grammar::RightRG < > ToGrammarRightRGGlushkov::convert ( const regexp::Unbounded
*/
for ( const auto & rule : grammar.getRawRules ( ) ) {
for ( const auto & rhs : rule.second )
- for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > & symbol : last ) {
+ for ( const regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > & symbol : last ) {
- const ext::pair < DefaultSymbolType, int > & a = symbol.getSymbol ( );
+ const ext::pair < DefaultSymbolType, unsigned > & a = symbol.getSymbol ( );
- if ( std::find ( rhs.begin ( ), rhs.end ( ), DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, int > ( a ) ) ) != rhs.end ( ) )
+ if ( std::find ( rhs.begin ( ), rhs.end ( ), DefaultSymbolType ( container::ObjectsPair < DefaultSymbolType, unsigned > ( a ) ) ) != rhs.end ( ) )
grammar.addRule ( rule.first, rhs.at ( 0 ) );
}
diff --git a/alib2algo/src/regexp/glushkov/GlushkovIndexate.h b/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
index 9659d1dab1ad7e28997ad55983d5ff8a12b98830..b800ff6f18cdad19f3deb28d6f20c2a08a5b7f1c 100644
--- a/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
+++ b/alib2algo/src/regexp/glushkov/GlushkovIndexate.h
@@ -31,65 +31,65 @@ public:
* @return UnboundedRegExp with indexed elements
*/
template < class SymbolType >
- static regexp::UnboundedRegExp < ext::pair < SymbolType, int > > index ( const regexp::UnboundedRegExp < SymbolType > & re );
+ static regexp::UnboundedRegExp < ext::pair < SymbolType, unsigned > > index ( const regexp::UnboundedRegExp < SymbolType > & re );
template < class SymbolType >
class Unbounded {
public:
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i);
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i);
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i);
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i);
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEpsilon < SymbolType > & epsilon, int & i);
- static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > visit(const regexp::UnboundedRegExpEmpty < SymbolType > & empty, int & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, unsigned & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, unsigned & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, unsigned & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, unsigned & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpEpsilon < SymbolType > & epsilon, unsigned & i);
+ static ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > visit(const regexp::UnboundedRegExpEmpty < SymbolType > & empty, unsigned & i);
};
};
template < class SymbolType >
-UnboundedRegExp < ext::pair < SymbolType, int > > GlushkovIndexate::index ( const regexp::UnboundedRegExp < SymbolType > & re ) {
- int i = 1;
+UnboundedRegExp < ext::pair < SymbolType, unsigned > > GlushkovIndexate::index ( const regexp::UnboundedRegExp < SymbolType > & re ) {
+ unsigned i = 1;
- return UnboundedRegExp < ext::pair < SymbolType, int > > ( regexp::UnboundedRegExpStructure < ext::pair < SymbolType, int > > ( re.getRegExp ( ).getStructure ( ).template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
+ return UnboundedRegExp < ext::pair < SymbolType, unsigned > > ( regexp::UnboundedRegExpStructure < ext::pair < SymbolType, unsigned > > ( re.getRegExp ( ).getStructure ( ).template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, int & i) {
- UnboundedRegExpAlternation < ext::pair < SymbolType, int > > alt;
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpAlternation < SymbolType > & alternation, unsigned & i) {
+ UnboundedRegExpAlternation < ext::pair < SymbolType, unsigned > > alt;
for ( const UnboundedRegExpElement < SymbolType > & element : alternation.getElements ( ) )
- alt.appendElement ( element.template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
+ alt.appendElement ( element.template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( std::move ( alt ) );
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( std::move ( alt ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, int & i) {
- UnboundedRegExpConcatenation < ext::pair < SymbolType, int > > con;
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpConcatenation < SymbolType > & concatenation, unsigned & i) {
+ UnboundedRegExpConcatenation < ext::pair < SymbolType, unsigned > > con;
for ( const UnboundedRegExpElement < SymbolType > & element : concatenation.getElements ( ) )
- con.appendElement ( element.template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
+ con.appendElement ( element.template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) );
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( std::move ( con ) );
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( std::move ( con ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, int & i) {
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( UnboundedRegExpIteration < ext::pair < SymbolType, int > > ( iteration.getElement ( ).template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < DefaultSymbolType, int > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpIteration < SymbolType > & iteration, unsigned & i) {
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( UnboundedRegExpIteration < ext::pair < SymbolType, unsigned > > ( iteration.getElement ( ).template accept < ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < DefaultSymbolType, unsigned > > >, GlushkovIndexate::Unbounded < SymbolType > > ( i ) ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, int & i) {
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( UnboundedRegExpSymbol < ext::pair < SymbolType, int > > ( ext::make_pair ( symbol.getSymbol ( ), i++ ) ) );
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpSymbol < SymbolType > & symbol, unsigned & i) {
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( UnboundedRegExpSymbol < ext::pair < SymbolType, unsigned > > ( ext::make_pair ( symbol.getSymbol ( ), i++ ) ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEpsilon < SymbolType > &, int &) {
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( UnboundedRegExpEpsilon < ext::pair < SymbolType, int > > ( ) );
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEpsilon < SymbolType > &, unsigned &) {
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( UnboundedRegExpEpsilon < ext::pair < SymbolType, unsigned > > ( ) );
}
template < class SymbolType >
-ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, int > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEmpty < SymbolType > &, int &) {
- return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, int > > > ( UnboundedRegExpEmpty < ext::pair < SymbolType, int > > ( ) );
+ext::ptr_value < regexp::UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > GlushkovIndexate::Unbounded < SymbolType >::visit(const regexp::UnboundedRegExpEmpty < SymbolType > &, unsigned &) {
+ return ext::ptr_value < UnboundedRegExpElement < ext::pair < SymbolType, unsigned > > > ( UnboundedRegExpEmpty < ext::pair < SymbolType, unsigned > > ( ) );
}
} /* namespace regexp */
diff --git a/alib2algo/test-src/regexp/RegExpTest.cpp b/alib2algo/test-src/regexp/RegExpTest.cpp
index 5e888267eeaee69fc24f8ebc858838937ceacc8a..bc4b8eae43245845f013cbea5a22a6e440161739 100644
--- a/alib2algo/test-src/regexp/RegExpTest.cpp
+++ b/alib2algo/test-src/regexp/RegExpTest.cpp
@@ -28,18 +28,18 @@ void RegExpTest::testFirst ( ) {
{
std::string input = "#E* #0*";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
CPPUNIT_ASSERT ( first.size ( ) == 0 );
}
{
std::string input = "#E* a";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > first = regexp::GlushkovFirst::first ( indexedRegExp );
CPPUNIT_ASSERT ( first.size ( ) == 1 );
}
@@ -49,18 +49,18 @@ void RegExpTest::testLast ( ) {
{
std::string input = "a+a";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > last = regexp::GlushkovLast::last ( indexedRegExp );
CPPUNIT_ASSERT ( last.size ( ) == 2 );
}
{
std::string input = "(a+a)b";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > last = regexp::GlushkovLast::last ( indexedRegExp );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > last = regexp::GlushkovLast::last ( indexedRegExp );
std::cout << last << std::endl;
CPPUNIT_ASSERT ( last.size ( ) == 1 );
@@ -71,52 +71,52 @@ void RegExpTest::testFollow ( ) {
{
std::string input = "(a+a)b";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow1.size ( ) == 1 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow2.size ( ) == 1 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow3.size ( ) == 0 );
}
{
std::string input = "a+a* (b+a)* c";
regexp::UnboundedRegExp < > regexp = factory::StringDataFactory::fromString ( input );
- regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, int > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
+ regexp::UnboundedRegExp < ext::pair < DefaultSymbolType, unsigned > > indexedRegExp = regexp::GlushkovIndexate::index ( regexp );
auto symbolsIter = indexedRegExp.getAlphabet ( ).begin ( );
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow1 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow1.size ( ) == 0 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow2 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow2.size ( ) == 4 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow3 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow3.size ( ) == 3 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow4 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow4 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow4.size ( ) == 3 );
symbolsIter++;
- ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > > follow5 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, int > > ( * symbolsIter ) );
+ ext::set < regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > > follow5 = regexp::GlushkovFollow::follow ( indexedRegExp, regexp::UnboundedRegExpSymbol < ext::pair < DefaultSymbolType, unsigned > > ( * symbolsIter ) );
CPPUNIT_ASSERT ( follow5.size ( ) == 0 );
}
diff --git a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
index 507c9d787b7779ebb1d2e0e84181de07ecfd1295..0ba7685992762086ec4db005964fc970cf2faa2b 100644
--- a/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
+++ b/alib2algo/test-src/regexp/toAutomaton/re2faTest.cpp
@@ -51,17 +51,17 @@ void re2faTest::testGlushkov() {
std::string input = "a+a*b*";
regexp::UnboundedRegExp < > regexp1 = factory::StringDataFactory::fromString ( input );
- automaton::NFA < > nfa1 = regexp::convert::ToAutomatonGlushkov::convert ( regexp1 );
+ automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > > nfa1 = regexp::convert::ToAutomatonGlushkov::convert ( regexp1 );
regexp::UnboundedRegExp < > regexp2 = automaton::convert::ToRegExpAlgebraic::convert ( nfa1 );
std::cout << regexp1 << std::endl;
std::cout << regexp2 << std::endl;
- automaton::NFA < > nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
+ automaton::NFA < DefaultSymbolType, ext::pair < DefaultSymbolType, unsigned > > nfa2 = regexp::convert::ToAutomatonGlushkov::convert(regexp2);
- automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > > dfa1 = automaton::determinize::Determinize::determinize(nfa1);
- automaton::DFA < DefaultSymbolType, ext::set < DefaultStateType > > dfa2 = automaton::determinize::Determinize::determinize(nfa2);
+ automaton::DFA < DefaultSymbolType, ext::set < ext::pair < DefaultSymbolType, unsigned > > > dfa1 = automaton::determinize::Determinize::determinize(nfa1);
+ automaton::DFA < DefaultSymbolType, ext::set < ext::pair < DefaultSymbolType, unsigned > > > dfa2 = automaton::determinize::Determinize::determinize(nfa2);
automaton::DFA< DefaultSymbolType, unsigned > mdfa1 = automaton::simplify::Normalize::normalize(automaton::simplify::Minimize::minimize(dfa1));
automaton::DFA< DefaultSymbolType, unsigned > mdfa2 = automaton::simplify::Normalize::normalize(automaton::simplify::Minimize::minimize(dfa2));